/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 4.0.2
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */


#ifndef SWIGPYTHON
#define SWIGPYTHON
#endif

#define SWIG_DIRECTORS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif


#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include <math.h>
#endif

#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
# undef _DEBUG
# include <Python.h>
# define _DEBUG 1
#else
# include <Python.h>
#endif

/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API SWIG runtime support for pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.

  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2
#define SWIG_POINTER_NO_NULL       0x4

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/*
   Flags/methods for returning states.

   The SWIG conversion methods, as ConvertPtr, return an integer
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).

   Use the following macros/flags to set or process the returning
   states.

   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }

   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {
        if (<obj is ok>) {
          if (<need new object>) {
            *ptr = <ptr to new allocated object>;
            return SWIG_NEWOBJ;
          } else {
            *ptr = <ptr to old object>;
            return SWIG_OLDOBJ;
          }
        } else {
          return SWIG_BADOBJ;
        }
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows to return the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call

      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0)
#define SWIG_ERROR                 (-1)
#define SWIG_IsOK(r)               (r >= 0)
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
#  define SWIG_AddCast(r) (r)
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;			/* mangled name of this type */
  const char             *str;			/* human readable name of this type */
  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
  void                   *clientdata;		/* language specific type data */
  int                    owndata;		/* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
  swig_converter_func     converter;		/* function to cast the void pointers */
  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
  struct swig_cast_info  *prev;			/* pointer to the previous cast */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;		        /* Number of types in this module */
  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;	/* Array of initially generated type structures */
  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
  void                    *clientdata;		/* Language specific module data */
} swig_module_info;

/*
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
		  const char *f2, const char *l2) {
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
  }
  return (int)((l1 - f1) - (l2 - f2));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
  int equiv = 1;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (equiv != 0 && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (strcmp(iter->type->name, c) == 0) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (iter->type == from) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}

/*
   Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
    ty = (*ty->dcast)(ptr);
    if (ty) lastty = ty;
  }
  return lastty;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  We choose
     to print the last name, as it is often (?) the most
     specific. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/*
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
	SWIG_TypeClientData(tc, clientdata);
      }
    }
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
                            swig_module_info *end,
		            const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      size_t l = 0;
      size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	size_t i = (l + r) >> 1;
	const char *iname = iter->types[i]->name;
	if (iname) {
	  int compare = strcmp(name, iname);
	  if (compare == 0) {
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
                     swig_module_info *end,
		     const char *name) {
  /* STEP 1: Search the name field using binary search */
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
  if (ret) {
    return ret;
  } else {
    /* STEP 2: If the type hasn't been found, do a complete search
       of the str field (the human readable name) */
    swig_module_info *iter = start;
    do {
      size_t i = 0;
      for (; i < iter->size; ++i) {
	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
	  return iter->types[i];
      }
      iter = iter->next;
    } while (iter != end);
  }

  /* neither found a match */
  return 0;
}

/*
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static const char hex[17] = "0123456789abcdef";
  const unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    unsigned char uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/*
   Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
  unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    char d = *(c++);
    unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = (unsigned char)((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = (unsigned char)((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (unsigned char)(d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (unsigned char)(d - ('a'-10));
    else
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/*
   Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
  char *r = buff;
  if ((2*sizeof(void *) + 2) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,&ptr,sizeof(void *));
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
  strcpy(r,name);
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      *ptr = (void *) 0;
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
}

SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
  char *r = buff;
  size_t lname = (name ? strlen(name) : 0);
  if ((2*sz + 2 + lname) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  if (lname) {
    strncpy(r,name,lname+1);
  } else {
    *r = 0;
  }
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      memset(ptr,0,sz);
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sz);
}

#ifdef __cplusplus
}
#endif

/*  Errors in SWIG */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13



/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000

#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)	
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#endif

#ifndef Py_TYPE
#  define Py_TYPE(op) ((op)->ob_type)
#endif

/* SWIG APIs for compatibility of both Python 2 & 3 */

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
#  define SWIG_Python_str_FromFormat PyString_FromFormat
#endif


/* Warning: This function will allocate a new string in Python 3,
 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
 */
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03030000
  return (char *)PyUnicode_AsUTF8(str);
#elif PY_VERSION_HEX >= 0x03000000
  char *newstr = 0;
  str = PyUnicode_AsUTF8String(str);
  if (str) {
    char *cstr;
    Py_ssize_t len;
    if (PyBytes_AsStringAndSize(str, &cstr, &len) != -1) {
      newstr = (char *) malloc(len+1);
      if (newstr)
        memcpy(newstr, cstr, len+1);
    }
    Py_XDECREF(str);
  }
  return newstr;
#else
  return PyString_AsString(str);
#endif
}

#if PY_VERSION_HEX >= 0x03030000 || PY_VERSION_HEX < 0x03000000
#  define SWIG_Python_str_DelForPy3(x)
#else
#  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
#endif


SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_FromString(c); 
#else
  return PyString_FromString(c);
#endif
}

#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

// SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user
// interface files check for it.
# define SWIGPY_USE_CAPSULE
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif

/* -----------------------------------------------------------------------------
 * error manipulation
 * ----------------------------------------------------------------------------- */

SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
  PyObject* type = 0;
  switch(code) {
  case SWIG_MemoryError:
    type = PyExc_MemoryError;
    break;
  case SWIG_IOError:
    type = PyExc_IOError;
    break;
  case SWIG_RuntimeError:
    type = PyExc_RuntimeError;
    break;
  case SWIG_IndexError:
    type = PyExc_IndexError;
    break;
  case SWIG_TypeError:
    type = PyExc_TypeError;
    break;
  case SWIG_DivisionByZero:
    type = PyExc_ZeroDivisionError;
    break;
  case SWIG_OverflowError:
    type = PyExc_OverflowError;
    break;
  case SWIG_SyntaxError:
    type = PyExc_SyntaxError;
    break;
  case SWIG_ValueError:
    type = PyExc_ValueError;
    break;
  case SWIG_SystemError:
    type = PyExc_SystemError;
    break;
  case SWIG_AttributeError:
    type = PyExc_AttributeError;
    break;
  default:
    type = PyExc_RuntimeError;
  }
  return type;
}


SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
  PyObject *type = 0;
  PyObject *value = 0;
  PyObject *traceback = 0;

  if (PyErr_Occurred())
    PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    PyObject *old_str = PyObject_Str(value);
    const char *tmp = SWIG_Python_str_AsChar(old_str);
    PyErr_Clear();
    Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(old_str);
    Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
  PyObject *error;
  if (obj)
    return 0;
  error = PyErr_Occurred();
  return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}

SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
  if (SWIG_Python_TypeErrorOccurred(NULL)) {
    /* Use existing TypeError to preserve stacktrace and enhance with given message */
    PyObject *newvalue;
    PyObject *type = NULL, *value = NULL, *traceback = NULL;
    PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
    newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
    newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
    Py_XDECREF(value);
    PyErr_Restore(type, newvalue, traceback);
  } else {
    /* Raise TypeError using given message */
    PyErr_SetString(PyExc_TypeError, message);
  }
}

#if defined(SWIG_PYTHON_NO_THREADS)
#  if defined(SWIG_PYTHON_THREADS)
#    undef SWIG_PYTHON_THREADS
#  endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
#    define SWIG_PYTHON_USE_GIL
#  endif
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
#    endif
#    ifdef __cplusplus /* C++ code */
       class SWIG_Python_Thread_Block {
         bool status;
         PyGILState_STATE state;
       public:
         void end() { if (status) { PyGILState_Release(state); status = false;} }
         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
         ~SWIG_Python_Thread_Block() { end(); }
       };
       class SWIG_Python_Thread_Allow {
         bool status;
         PyThreadState *save;
       public:
         void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
         ~SWIG_Python_Thread_Allow() { end(); }
       };
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
#    else /* C code */
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
#    endif
#  else /* Old thread way, not implemented, user must provide it */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      define SWIG_PYTHON_INITIALIZE_THREADS
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
#      define SWIG_PYTHON_THREAD_END_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
#      define SWIG_PYTHON_THREAD_END_ALLOW
#    endif
#  endif
#else /* No thread support */
#  define SWIG_PYTHON_INITIALIZE_THREADS
#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#  define SWIG_PYTHON_THREAD_END_BLOCK
#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#  define SWIG_PYTHON_THREAD_END_ALLOW
#endif

/* -----------------------------------------------------------------------------
 * Python API portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * Constant declarations
 * ----------------------------------------------------------------------------- */

/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Constant information structure */
typedef struct swig_const_info {
  int type;
  const char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;

#ifdef __cplusplus
}
#endif


/* -----------------------------------------------------------------------------
 * pyrun.swg
 *
 * This file contains the runtime support for Python modules
 * and includes code for managing global variables and pointer
 * type checking.
 *
 * ----------------------------------------------------------------------------- */

#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif

#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000
# error "This version of SWIG only supports Python 3 >= 3.2"
#endif

/* Common SWIG API */

/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)

#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif

#define SWIG_InternalNewPointerObj(ptr, type, flags)	SWIG_Python_NewPointerObj(NULL, ptr, type, flags)

#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype                                    int

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)

/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)

/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)

/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)

#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
#define SWIG_fail                        		goto fail					   


/* Runtime API implementation */

/* Error manipulation */

SWIGINTERN void 
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
  PyErr_SetObject(errtype, obj);
  Py_DECREF(obj);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

SWIGINTERN void 
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  PyErr_SetString(errtype, msg);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
  PyObject *s = PyString_InternFromString(key);
  PyList_Append(seq, s);
  Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  Py_DECREF(obj);                            
}

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      PyList_SetItem(result, 0, o2);
    }
    PyList_Append(result,obj);
    Py_DECREF(obj);
  }
  return result;
}

/* Unpack the argument tuple */

SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
  if (!args) {
    if (!min && !max) {
      return 1;
    } else {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
		   name, (min == max ? "" : "at least "), (int)min);
      return 0;
    }
  }  
  if (!PyTuple_Check(args)) {
    if (min <= 1 && max >= 1) {
      Py_ssize_t i;
      objs[0] = args;
      for (i = 1; i < max; ++i) {
	objs[i] = 0;
      }
      return 2;
    }
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    return 0;
  } else {
    Py_ssize_t l = PyTuple_GET_SIZE(args);
    if (l < min) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at least "), (int)min, (int)l);
      return 0;
    } else if (l > max) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at most "), (int)max, (int)l);
      return 0;
    } else {
      Py_ssize_t i;
      for (i = 0; i < l; ++i) {
	objs[i] = PyTuple_GET_ITEM(args, i);
      }
      for (; l < max; ++l) {
	objs[l] = 0;
      }
      return i + 1;
    }    
  }
}

SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
  int no_kwargs = 1;
  if (kwargs) {
    assert(PyDict_Check(kwargs));
    if (PyDict_Size(kwargs) > 0) {
      PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
      no_kwargs = 0;
    }
  }
  return no_kwargs;
}

/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);

/*
  Helper for static pointer initialization for both C and C++ code, for example
  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var)  var
#else
#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
#endif

/* -----------------------------------------------------------------------------
 * Pointer declarations
 * ----------------------------------------------------------------------------- */

/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

#define SWIG_BUILTIN_TP_INIT	    (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT	    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)

#ifdef __cplusplus
extern "C" {
#endif

/* The python void return value */

SWIGRUNTIMEINLINE PyObject * 
SWIG_Py_Void(void)
{
  PyObject *none = Py_None;
  Py_INCREF(none);
  return none;
}

/* SwigPyClientData */

typedef struct {
  PyObject *klass;
  PyObject *newraw;
  PyObject *newargs;
  PyObject *destroy;
  int delargs;
  int implicitconv;
  PyTypeObject *pytype;
} SwigPyClientData;

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  int fail = data ? data->implicitconv : 0;
  if (fail)
    PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
  return fail;
}

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
  PyObject *klass = data ? data->klass : 0;
  return (klass ? klass : PyExc_RuntimeError);
}


SWIGRUNTIME SwigPyClientData * 
SwigPyClientData_New(PyObject* obj)
{
  if (!obj) {
    return 0;
  } else {
    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    /* the klass element */
    data->klass = obj;
    Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      data->newargs = obj;
      Py_INCREF(obj);
    } else {
      data->newraw = PyObject_GetAttrString(data->klass, "__new__");
      if (data->newraw) {
	Py_INCREF(data->newraw);
	data->newargs = PyTuple_New(1);
	PyTuple_SetItem(data->newargs, 0, obj);
      } else {
	data->newargs = obj;
      }
      Py_INCREF(data->newargs);
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      int flags;
      Py_INCREF(data->destroy);
      flags = PyCFunction_GET_FLAGS(data->destroy);
      data->delargs = !(flags & (METH_O));
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

SWIGRUNTIME void 
SwigPyClientData_Del(SwigPyClientData *data) {
  Py_XDECREF(data->newraw);
  Py_XDECREF(data->newargs);
  Py_XDECREF(data->destroy);
}

/* =============== SwigPyObject =====================*/

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
  PyObject *dict;
#endif
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;

  if (!sobj->dict)
    sobj->dict = PyDict_New();

  Py_INCREF(sobj->dict);
  return sobj->dict;
}

#endif

SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
  return PyLong_FromVoidPtr(v->ptr);
}

SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
  PyObject *res = NULL;
  PyObject *args = PyTuple_New(1);
  if (args) {
    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
      PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
      if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
	res = PyUnicode_Format(ofmt,args);
#else
	res = PyString_Format(ofmt,args);
#endif
	Py_DECREF(ofmt);
      }
      Py_DECREF(args);
    }
  }
  return res;
}

SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
  return SwigPyObject_format("%o",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
  return SwigPyObject_format("%x",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
  if (v->next) {
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
# if PY_VERSION_HEX >= 0x03000000
    PyObject *joined = PyUnicode_Concat(repr, nrep);
    Py_DecRef(repr);
    Py_DecRef(nrep);
    repr = joined;
# else
    PyString_ConcatAndDel(&repr,nrep);
# endif
  }
  return repr;  
}

/* We need a version taking two PyObject* parameters so it's a valid
 * PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  return SwigPyObject_repr((SwigPyObject*)v);
}

SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
  void *i = v->ptr;
  void *j = w->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
  PyObject* res;
  if( op != Py_EQ && op != Py_NE ) {
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
  }
  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
  return res;  
}


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
    SwigPyClientData *cd;
    assert(SwigPyObject_stype);
    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    assert(cd);
    assert(cd->pytype);
    return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
  return type;
}
#endif

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
  PyTypeObject *target_tp = SwigPyObject_type();
  if (PyType_IsSubtype(op->ob_type, target_tp))
    return 1;
  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
  return (Py_TYPE(op) == SwigPyObject_type())
    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);

SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  PyObject *next = sobj->next;
  if (sobj->own == SWIG_POINTER_OWN) {
    swig_type_info *ty = sobj->ty;
    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    PyObject *destroy = data ? data->destroy : 0;
    if (destroy) {
      /* destroy is always a VARARGS method */
      PyObject *res;

      /* PyObject_CallFunction() has the potential to silently drop
         the active exception.  In cases of unnamed temporary
         variable or where we just finished iterating over a generator
         StopIteration will be active right now, and this needs to
         remain true upon return from SwigPyObject_dealloc.  So save
         and restore. */
      
      PyObject *type = NULL, *value = NULL, *traceback = NULL;
      PyErr_Fetch(&type, &value, &traceback);

      if (data->delargs) {
        /* we need to create a temporary object to carry the destroy operation */
        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
        res = SWIG_Python_CallFunctor(destroy, tmp);
        Py_DECREF(tmp);
      } else {
        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
        PyObject *mself = PyCFunction_GET_SELF(destroy);
        res = ((*meth)(mself, v));
      }
      if (!res)
        PyErr_WriteUnraisable(destroy);

      PyErr_Restore(type, value, traceback);

      Py_XDECREF(res);
    } 
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    else {
      const char *name = SWIG_TypePrettyName(ty);
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    }
#endif
  } 
  Py_XDECREF(next);
  PyObject_DEL(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  sobj->next = next;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    Py_INCREF(sobj->next);
    return sobj->next;
  } else {
    return SWIG_Py_Void();
  }
}

SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = 0;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = SWIG_POINTER_OWN;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
  PyObject *val = 0;
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
    return NULL;
  } else {
    SwigPyObject *sobj = (SwigPyObject *)v;
    PyObject *obj = PyBool_FromLong(sobj->own);
    if (val) {
      if (PyObject_IsTrue(val)) {
        SwigPyObject_acquire(v,args);
      } else {
        SwigPyObject_disown(v,args);
      }
    } 
    return obj;
  }
}

static PyMethodDef
swigobject_methods[] = {
  {"disown",  SwigPyObject_disown,  METH_NOARGS,  "releases ownership of the pointer"},
  {"acquire", SwigPyObject_acquire, METH_NOARGS,  "acquires ownership of the pointer"},
  {"own",     SwigPyObject_own,     METH_VARARGS, "returns/sets ownership of the pointer"},
  {"append",  SwigPyObject_append,  METH_O,       "appends another 'this' object"},
  {"next",    SwigPyObject_next,    METH_NOARGS,  "returns the next 'this' object"},
  {"__repr__",SwigPyObject_repr2,   METH_NOARGS,  "returns object representation"},
  {0, 0, 0, 0}  
};

SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";

  static PyNumberMethods SwigPyObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    /* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc)0, /*nb_divide*/
#endif
    (binaryfunc)0, /*nb_remainder*/
    (binaryfunc)0, /*nb_divmod*/
    (ternaryfunc)0,/*nb_power*/
    (unaryfunc)0,  /*nb_negative*/
    (unaryfunc)0,  /*nb_positive*/
    (unaryfunc)0,  /*nb_absolute*/
    (inquiry)0,    /*nb_nonzero*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
    0,   /*nb_coerce*/
#endif
    (unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_long, /*nb_long*/
#else
    0, /*nb_reserved*/
#endif
    (unaryfunc)0,                 /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      "SwigPyObject",                       /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
      0,                                    /* tp_print */
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
      &SwigPyObject_as_number,              /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      0,                                    /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigobject_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      swigobject_methods,                   /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) < 0)
      return NULL;
  }
  return &swigpyobject_type;
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
  if (sobj) {
    sobj->ptr  = ptr;
    sobj->ty   = ty;
    sobj->own  = own;
    sobj->next = 0;
  }
  return (PyObject *)sobj;
}

/* -----------------------------------------------------------------------------
 * Implements a simple Swig Packed type, and use it instead of string
 * ----------------------------------------------------------------------------- */

typedef struct {
  PyObject_HEAD
  void *pack;
  swig_type_info *ty;
  size_t size;
} SwigPyPacked;

SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
  }  
}

SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromChar(v->ty->name);
  }  
}

SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
  size_t i = v->size;
  size_t j = w->size;
  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
  return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
  return type;
}

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
  return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
    || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}

SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
  if (SwigPyPacked_Check(v)) {
    SwigPyPacked *sobj = (SwigPyPacked *) v;
    free(sobj->pack);
  }
  PyObject_DEL(v);
}

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      "SwigPyPacked",                       /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
      0,                                    /* tp_print */
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
      0, /* tp_reserved in 3.0.1 */
#else
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
      0,                                    /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      (reprfunc)SwigPyPacked_str,           /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigpacked_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      0,                                    /* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      0,                                    /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) < 0)
      return NULL;
  }
  return &swigpypacked_type;
}

SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
  if (sobj) {
    void *pack = malloc(size);
    if (pack) {
      memcpy(pack, ptr, size);
      sobj->pack = pack;
      sobj->ty   = ty;
      sobj->size = size;
    } else {
      PyObject_DEL((PyObject *) sobj);
      sobj = 0;
    }
  }
  return (PyObject *) sobj;
}

SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
  if (SwigPyPacked_Check(obj)) {
    SwigPyPacked *sobj = (SwigPyPacked *)obj;
    if (sobj->size != size) return 0;
    memcpy(ptr, sobj->pack, size);
    return sobj->ty;
  } else {
    return 0;
  }
}

/* -----------------------------------------------------------------------------
 * pointers/data manipulation
 * ----------------------------------------------------------------------------- */

static PyObject *Swig_This_global = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (Swig_This_global == NULL)
    Swig_This_global = SWIG_Python_str_FromChar("this");
  return Swig_This_global;
}

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS 
#endif

SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

  if (SwigPyObject_Check(pyobj))
    return (SwigPyObject *) pyobj;

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
# ifdef PyWeakref_CheckProxy
  if (PyWeakref_CheckProxy(pyobj)) {
    pyobj = PyWeakref_GET_OBJECT(pyobj);
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
# endif
  return NULL;
#else

  obj = 0;

#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  if (PyInstance_Check(pyobj)) {
    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
  } else {
    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    if (dictptr != NULL) {
      PyObject *dict = *dictptr;
      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    } else {
#ifdef PyWeakref_CheckProxy
      if (PyWeakref_CheckProxy(pyobj)) {
	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
      }
#endif
      obj = PyObject_GetAttr(pyobj,SWIG_This());
      if (obj) {
	Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj,SWIG_This());
  if (obj) {
    Py_DECREF(obj);
  } else {
    if (PyErr_Occurred()) PyErr_Clear();
    return 0;
  }
#endif
  if (obj && !SwigPyObject_Check(obj)) {
    /* a PyObject is called 'this', try to get the 'real this'
       SwigPyObject from it */ 
    return SWIG_Python_GetSwigThis(obj);
  }
  return (SwigPyObject *)obj;
#endif
}

/* Acquire a pointer value */

SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
  if (own == SWIG_POINTER_OWN) {
    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    if (sobj) {
      int oldown = sobj->own;
      sobj->own = own;
      return oldown;
    }
  }
  return 0;
}

/* Convert a pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
  int res;
  SwigPyObject *sobj;
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None && !implicit_conv) {
    if (ptr)
      *ptr = 0;
    return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
  }

  res = SWIG_ERROR;

  sobj = SWIG_Python_GetSwigThis(obj);
  if (own)
    *own = 0;
  while (sobj) {
    void *vptr = sobj->ptr;
    if (ty) {
      swig_type_info *to = sobj->ty;
      if (to == ty) {
        /* no type cast needed */
        if (ptr) *ptr = vptr;
        break;
      } else {
        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
        if (!tc) {
          sobj = (SwigPyObject *)sobj->next;
        } else {
          if (ptr) {
            int newmemory = 0;
            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
            if (newmemory == SWIG_CAST_NEW_MEMORY) {
              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
              if (own)
                *own = *own | SWIG_CAST_NEW_MEMORY;
            }
          }
          break;
        }
      }
    } else {
      if (ptr) *ptr = vptr;
      break;
    }
  }
  if (sobj) {
    if (own)
      *own = *own | sobj->own;
    if (flags & SWIG_POINTER_DISOWN) {
      sobj->own = 0;
    }
    res = SWIG_OK;
  } else {
    if (implicit_conv) {
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
      if (data && !data->implicitconv) {
        PyObject *klass = data->klass;
        if (klass) {
          PyObject *impconv;
          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
          impconv = SWIG_Python_CallFunctor(klass, obj);
          data->implicitconv = 0;
          if (PyErr_Occurred()) {
            PyErr_Clear();
            impconv = 0;
          }
          if (impconv) {
            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
            if (iobj) {
              void *vptr;
              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
              if (SWIG_IsOK(res)) {
                if (ptr) {
                  *ptr = vptr;
                  /* transfer the ownership to 'ptr' */
                  iobj->own = 0;
                  res = SWIG_AddCast(res);
                  res = SWIG_AddNewMask(res);
                } else {
                  res = SWIG_AddCast(res);		    
                }
              }
            }
            Py_DECREF(impconv);
          }
        }
      }
      if (!SWIG_IsOK(res) && obj == Py_None) {
        if (ptr)
          *ptr = 0;
        if (PyErr_Occurred())
          PyErr_Clear();
        res = SWIG_OK;
      }
    }
  }
  return res;
}

/* Convert a function ptr value */

SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
  if (!PyCFunction_Check(obj)) {
    return SWIG_ConvertPtr(obj, ptr, ty, 0);
  } else {
    void *vptr = 0;
    swig_cast_info *tc;

    /* here we get the method pointer for callbacks */
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
    if (!desc)
      return SWIG_ERROR;
    tc = SWIG_TypeCheck(desc,ty);
    if (tc) {
      int newmemory = 0;
      *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
      assert(!newmemory); /* newmemory handling not yet implemented */
    } else {
      return SWIG_ERROR;
    }
    return SWIG_OK;
  }
}

/* Convert a packed pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
  if (!to) return SWIG_ERROR;
  if (ty) {
    if (to != ty) {
      /* check type cast? */
      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
      if (!tc) return SWIG_ERROR;
    }
  }
  return SWIG_OK;
}  

/* -----------------------------------------------------------------------------
 * Create a new pointer object
 * ----------------------------------------------------------------------------- */

/*
  Create a new instance object, without calling __init__, and set the
  'this' attribute.
*/

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
	PyObject *dict = *dictptr;
	if (dict == NULL) {
	  dict = PyDict_New();
	  *dictptr = dict;
	  PyDict_SetItem(dict, SWIG_This(), swig_this);
	}
      }
#else
      if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
        Py_DECREF(inst);
        inst = 0;
      }
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *empty_args = PyTuple_New(0);
    if (empty_args) {
      PyObject *empty_kwargs = PyDict_New();
      if (empty_kwargs) {
        inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        Py_DECREF(empty_kwargs);
        if (inst) {
          if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
            Py_DECREF(inst);
            inst = 0;
          } else {
            Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
          }
        }
      }
      Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      Py_DECREF(dict);
    }
#endif
  }
  return inst;
}

SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  PyObject **dictptr = _PyObject_GetDictPtr(inst);
  if (dictptr != NULL) {
    PyObject *dict = *dictptr;
    if (dict == NULL) {
      dict = PyDict_New();
      *dictptr = dict;
    }
    return PyDict_SetItem(dict, SWIG_This(), swig_this);
  }
#endif
  return PyObject_SetAttr(inst, SWIG_This(), swig_this);
} 


SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
  PyObject *obj[2];
  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    return NULL;
  } else {
    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    if (sthis) {
      SwigPyObject_append((PyObject*) sthis, obj[1]);
    } else {
      if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
        return NULL;
    }
    return SWIG_Py_Void();
  }
}

/* Create a new pointer object */

SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
  SwigPyClientData *clientdata;
  PyObject * robj;
  int own;

  if (!ptr)
    return SWIG_Py_Void();

  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
  if (clientdata && clientdata->pytype) {
    SwigPyObject *newobj;
    if (flags & SWIG_BUILTIN_TP_INIT) {
      newobj = (SwigPyObject*) self;
      if (newobj->ptr) {
        PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
        newobj->dict = 0;
#endif
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
      newobj->dict = 0;
#endif
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

  robj = SwigPyObject_New(ptr, type, own);
  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    Py_DECREF(robj);
    robj = inst;
  }
  return robj;
}

/* Create a new packed object */

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}

/* -----------------------------------------------------------------------------*
 *  Get type list 
 * -----------------------------------------------------------------------------*/

#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif

SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
  static void *type_pointer = (void *)0;
  /* first check if module already created */
  if (!type_pointer) {
#ifdef SWIG_LINK_RUNTIME
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
#else
    type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
    if (PyErr_Occurred()) {
      PyErr_Clear();
      type_pointer = (void *)0;
    }
#endif
  }
  return (swig_module_info *) type_pointer;
}

SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
  swig_type_info **types = swig_module->types;
  size_t i;
  for (i =0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      if (data) SwigPyClientData_Del(data);
    }
  }
  Py_DECREF(SWIG_This());
  Swig_This_global = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
 /* Add a dummy module object into sys.modules */
  PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
  PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
  } else {
    Py_XDECREF(pointer);
  }
}

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
  return cache;
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *key = SWIG_Python_str_FromChar(type); 
  PyObject *obj = PyDict_GetItem(cache, key);
  swig_type_info *descriptor;
  if (obj) {
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
      PyDict_SetItem(cache, key, obj);
      Py_DECREF(obj);
    }
  }
  Py_DECREF(key);
  return descriptor;
}

/* 
   For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION  0
#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)

SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{  
  if (PyErr_Occurred()) {
    PyObject *type = 0;
    PyObject *value = 0;
    PyObject *traceback = 0;
    PyErr_Fetch(&type, &value, &traceback);
    if (value) {
      PyObject *old_str = PyObject_Str(value);
      const char *tmp = SWIG_Python_str_AsChar(old_str);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, mesg);
      }
      SWIG_Python_str_DelForPy3(tmp);
      Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}
  
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}

SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
  SwigPyObject *v = (SwigPyObject *)self;
  swig_type_info *ty = v ? v->ty : 0;
  return ty ? ty->str : "";
}

SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
  if (type) {
#if defined(SWIG_COBJECT_TYPES)
    if (obj && SwigPyObject_Check(obj)) {
      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
		     type, otype);
	return;
      }
    } else 
#endif      
    {
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
          SWIG_Python_str_DelForPy3(cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	Py_XDECREF(str);
	return;
      }
    }   
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
  } else {
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
  }
}


/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
  void *result;
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    PyErr_Clear();
#if SWIG_POINTER_EXCEPTION
    if (flags) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
      SWIG_Python_ArgFail(argnum);
    }
#endif
  }
  return result;
}

#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
  PyTypeObject *tp = obj->ob_type;
  PyObject *descr;
  PyObject *encoded_name;
  descrsetfunc f;
  int res = -1;

# ifdef Py_USING_UNICODE
  if (PyString_Check(name)) {
    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    if (!name)
      return -1;
  } else if (!PyUnicode_Check(name))
# else
  if (!PyString_Check(name))
# endif
  {
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    return -1;
  } else {
    Py_INCREF(name);
  }

  if (!tp->tp_dict) {
    if (PyType_Ready(tp) < 0)
      goto done;
  }

  descr = _PyType_Lookup(tp, name);
  f = NULL;
  if (descr != NULL)
    f = descr->ob_type->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        return -1;
    }
    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  Py_DECREF(name);
  return res;
}
#endif


#ifdef __cplusplus
}
#endif



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 



#ifdef __cplusplus
extern "C" {
#endif

/* Method creation and docstring support functions */

SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);

#ifdef __cplusplus
}
#endif


  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 

/* -----------------------------------------------------------------------------
 * director_common.swg
 *
 * This file contains support for director classes which is common between
 * languages.
 * ----------------------------------------------------------------------------- */

/*
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
  'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif
/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that Python proxy
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
#define SWIG_DIRECTOR_PYTHON_HEADER_

#include <string>
#include <iostream>
#include <exception>
#include <vector>
#include <map>


/*
  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
  table', and avoid multiple GetAttr calls to retrieve the python
  methods.
*/

#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE
#ifndef SWIG_PYTHON_DIRECTOR_VTABLE
#define SWIG_PYTHON_DIRECTOR_VTABLE
#endif
#endif



/*
  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
  Undefined Exception Handler provided by swig.
*/
#ifndef SWIG_DIRECTOR_NO_UEH
#ifndef SWIG_DIRECTOR_UEH
#define SWIG_DIRECTOR_UEH
#endif
#endif


/*
  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
  native C++ RTTI and dynamic_cast<>. But be aware that directors
  could stop working when using this option.
*/
#ifdef SWIG_DIRECTOR_NORTTI
/*
   When we don't use the native C++ RTTI, we implement a minimal one
   only for Directors.
*/
# ifndef SWIG_DIRECTOR_RTDIR
# define SWIG_DIRECTOR_RTDIR

namespace Swig {
  class Director;
  SWIGINTERN std::map<void *, Director *>& get_rtdir_map() {
    static std::map<void *, Director *> rtdir_map;
    return rtdir_map;
  }

  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
    get_rtdir_map()[vptr] = rtdir;
  }

  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
    std::map<void *, Director *>::const_iterator pos = get_rtdir_map().find(vptr);
    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
    return rtdir;
  }
}
# endif /* SWIG_DIRECTOR_RTDIR */

# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void *>(ARG))
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void *>(ARG1), ARG2)

#else

# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2)

#endif /* SWIG_DIRECTOR_NORTTI */

extern "C" {
  struct swig_type_info;
}

namespace Swig {

  /* memory handler */
  struct GCItem {
    virtual ~GCItem() {}

    virtual int get_own() const {
      return 0;
    }
  };

  struct GCItem_var {
    GCItem_var(GCItem *item = 0) : _item(item) {
    }

    GCItem_var& operator=(GCItem *item) {
      GCItem *tmp = _item;
      _item = item;
      delete tmp;
      return *this;
    }

    ~GCItem_var() {
      delete _item;
    }

    GCItem * operator->() const {
      return _item;
    }

  private:
    GCItem *_item;
  };

  struct GCItem_Object : GCItem {
    GCItem_Object(int own) : _own(own) {
    }

    virtual ~GCItem_Object() {
    }

    int get_own() const {
      return _own;
    }

  private:
    int _own;
  };

  template <typename Type>
  struct GCItem_T : GCItem {
    GCItem_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCItem_T() {
      delete _ptr;
    }

  private:
    Type *_ptr;
  };

  template <typename Type>
  struct GCArray_T : GCItem {
    GCArray_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCArray_T() {
      delete[] _ptr;
    }

  private:
    Type *_ptr;
  };

  /* base class for director exceptions */
  class DirectorException : public std::exception {
  protected:
    std::string swig_msg;
  public:
    DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (msg[0]) {
        swig_msg += " ";
        swig_msg += msg;
      }
      if (!PyErr_Occurred()) {
        PyErr_SetString(error, what());
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
    }

    virtual ~DirectorException() throw() {
    }

    /* Deprecated, use what() instead */
    const char *getMessage() const {
      return what();
    }

    const char *what() const throw() {
      return swig_msg.c_str();
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorException(error, msg);
    }

    static void raise(const char *msg) {
      raise(PyExc_RuntimeError, msg);
    }
  };

  /* type mismatch in the return value from a python method call */
  class DirectorTypeMismatchException : public DirectorException {
  public:
    DirectorTypeMismatchException(PyObject *error, const char *msg="")
      : DirectorException(error, "SWIG director type mismatch", msg) {
    }

    DirectorTypeMismatchException(const char *msg="")
      : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) {
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorTypeMismatchException(error, msg);
    }

    static void raise(const char *msg) {
      throw DirectorTypeMismatchException(msg);
    }
  };

  /* any python exception that occurs during a director method call */
  class DirectorMethodException : public DirectorException {
  public:
    DirectorMethodException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorMethodException(msg);
    }
  };

  /* attempt to call a pure virtual method via a director method */
  class DirectorPureVirtualException : public DirectorException {
  public:
    DirectorPureVirtualException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorPureVirtualException(msg);
    }
  };


#if defined(SWIG_PYTHON_THREADS)
/*  __THREAD__ is the old macro to activate some thread support */
# if !defined(__THREAD__)
#   define __THREAD__ 1
# endif
#endif

#ifdef __THREAD__
# include "pythread.h"
  class Guard {
    PyThread_type_lock &mutex_;

  public:
    Guard(PyThread_type_lock & mutex) : mutex_(mutex) {
      PyThread_acquire_lock(mutex_, WAIT_LOCK);
    }

    ~Guard() {
      PyThread_release_lock(mutex_);
    }
  };
# define SWIG_GUARD(mutex) Guard _guard(mutex)
#else
# define SWIG_GUARD(mutex)
#endif

  /* director base class */
  class Director {
  private:
    /* pointer to the wrapped python object */
    PyObject *swig_self;
    /* flag indicating whether the object is owned by python or c++ */
    mutable bool swig_disown_flag;

    /* decrement the reference count of the wrapped python object */
    void swig_decref() const {
      if (swig_disown_flag) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        Py_DECREF(swig_self);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }

  public:
    /* wrap a python object. */
    Director(PyObject *self) : swig_self(self), swig_disown_flag(false) {
    }

    /* discard our reference at destruction */
    virtual ~Director() {
      swig_decref();
    }

    /* return a pointer to the wrapped python object */
    PyObject *swig_get_self() const {
      return swig_self;
    }

    /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */
    void swig_disown() const {
      if (!swig_disown_flag) {
        swig_disown_flag=true;
        swig_incref();
      }
    }

    /* increase the reference count of the wrapped python object */
    void swig_incref() const {
      if (swig_disown_flag) {
        Py_INCREF(swig_self);
      }
    }

    /* methods to implement pseudo protected director members */
    virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const {
      return true;
    }

    virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const {
    }

  /* ownership management */
  private:
    typedef std::map<void *, GCItem_var> swig_ownership_map;
    mutable swig_ownership_map swig_owner;
#ifdef __THREAD__
    static PyThread_type_lock swig_mutex_own;
#endif

  public:
    template <typename Type>
    void swig_acquire_ownership_array(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCArray_T<Type>(vptr);
      }
    }

    template <typename Type>
    void swig_acquire_ownership(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_T<Type>(vptr);
      }
    }

    void swig_acquire_ownership_obj(void *vptr, int own) const {
      if (vptr && own) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_Object(own);
      }
    }

    int swig_release_ownership(void *vptr) const {
      int own = 0;
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_ownership_map::iterator iter = swig_owner.find(vptr);
        if (iter != swig_owner.end()) {
          own = iter->second->get_own();
          swig_owner.erase(iter);
        }
      }
      return own;
    }

    template <typename Type>
    static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) {
      SwigPyObject *sobj = (SwigPyObject *)pyobj;
      sobj->own = 0;
      Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
      if (d)
        d->swig_disown();
      return PyWeakref_NewProxy(pyobj, NULL);
    }
  };

#ifdef __THREAD__
  PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock();
#endif
}

#endif

/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_ASTBasePlugin swig_types[0]
#define SWIGTYPE_p_ASTNode swig_types[1]
#define SWIGTYPE_p_ASTNodeType_t swig_types[2]
#define SWIGTYPE_p_ASTNodeValues_t swig_types[3]
#define SWIGTYPE_p_AlgebraicRule swig_types[4]
#define SWIGTYPE_p_AllowedChildrenType_t swig_types[5]
#define SWIGTYPE_p_AssignmentRule swig_types[6]
#define SWIGTYPE_p_BiolQualifierType_t swig_types[7]
#define SWIGTYPE_p_CVTerm swig_types[8]
#define SWIGTYPE_p_Callback swig_types[9]
#define SWIGTYPE_p_CallbackRegistry swig_types[10]
#define SWIGTYPE_p_Compartment swig_types[11]
#define SWIGTYPE_p_CompartmentType swig_types[12]
#define SWIGTYPE_p_Constraint swig_types[13]
#define SWIGTYPE_p_ConversionOption swig_types[14]
#define SWIGTYPE_p_ConversionOptionType_t swig_types[15]
#define SWIGTYPE_p_ConversionProperties swig_types[16]
#define SWIGTYPE_p_Date swig_types[17]
#define SWIGTYPE_p_DefinitionURLRegistry swig_types[18]
#define SWIGTYPE_p_Delay swig_types[19]
#define SWIGTYPE_p_ElementFilter swig_types[20]
#define SWIGTYPE_p_ElementTransformer swig_types[21]
#define SWIGTYPE_p_Event swig_types[22]
#define SWIGTYPE_p_EventAssignment swig_types[23]
#define SWIGTYPE_p_ExpectedAttributes swig_types[24]
#define SWIGTYPE_p_ExtendedMathType_t swig_types[25]
#define SWIGTYPE_p_FormulaUnitsData swig_types[26]
#define SWIGTYPE_p_FunctionDefinition swig_types[27]
#define SWIGTYPE_p_ISBMLExtensionNamespaces swig_types[28]
#define SWIGTYPE_p_IdList swig_types[29]
#define SWIGTYPE_p_IdentifierTransformer swig_types[30]
#define SWIGTYPE_p_InitialAssignment swig_types[31]
#define SWIGTYPE_p_KineticLaw swig_types[32]
#define SWIGTYPE_p_L3ParserGrammarLineType_t swig_types[33]
#define SWIGTYPE_p_L3ParserSettings swig_types[34]
#define SWIGTYPE_p_List swig_types[35]
#define SWIGTYPE_p_ListNode swig_types[36]
#define SWIGTYPE_p_ListOf swig_types[37]
#define SWIGTYPE_p_ListOfCompartmentTypes swig_types[38]
#define SWIGTYPE_p_ListOfCompartments swig_types[39]
#define SWIGTYPE_p_ListOfConstraints swig_types[40]
#define SWIGTYPE_p_ListOfEventAssignments swig_types[41]
#define SWIGTYPE_p_ListOfEvents swig_types[42]
#define SWIGTYPE_p_ListOfFunctionDefinitions swig_types[43]
#define SWIGTYPE_p_ListOfInitialAssignments swig_types[44]
#define SWIGTYPE_p_ListOfLocalParameters swig_types[45]
#define SWIGTYPE_p_ListOfParameters swig_types[46]
#define SWIGTYPE_p_ListOfReactions swig_types[47]
#define SWIGTYPE_p_ListOfRules swig_types[48]
#define SWIGTYPE_p_ListOfSpecies swig_types[49]
#define SWIGTYPE_p_ListOfSpeciesReferences swig_types[50]
#define SWIGTYPE_p_ListOfSpeciesTypes swig_types[51]
#define SWIGTYPE_p_ListOfUnitDefinitions swig_types[52]
#define SWIGTYPE_p_ListOfUnits swig_types[53]
#define SWIGTYPE_p_ListWrapperT_ASTNode_t swig_types[54]
#define SWIGTYPE_p_ListWrapperT_CVTerm_t swig_types[55]
#define SWIGTYPE_p_ListWrapperT_Date_t swig_types[56]
#define SWIGTYPE_p_ListWrapperT_ModelCreator_t swig_types[57]
#define SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t swig_types[58]
#define SWIGTYPE_p_ListWrapperT_SBase_t swig_types[59]
#define SWIGTYPE_p_LocalParameter swig_types[60]
#define SWIGTYPE_p_MathFilter swig_types[61]
#define SWIGTYPE_p_Model swig_types[62]
#define SWIGTYPE_p_ModelCreator swig_types[63]
#define SWIGTYPE_p_ModelHistory swig_types[64]
#define SWIGTYPE_p_ModelQualifierType_t swig_types[65]
#define SWIGTYPE_p_ModifierSpeciesReference swig_types[66]
#define SWIGTYPE_p_OperationReturnValues_t swig_types[67]
#define SWIGTYPE_p_Parameter swig_types[68]
#define SWIGTYPE_p_ParseLogType_t swig_types[69]
#define SWIGTYPE_p_Priority swig_types[70]
#define SWIGTYPE_p_QualifierType_t swig_types[71]
#define SWIGTYPE_p_RDFAnnotationParser swig_types[72]
#define SWIGTYPE_p_RateRule swig_types[73]
#define SWIGTYPE_p_Reaction swig_types[74]
#define SWIGTYPE_p_Rule swig_types[75]
#define SWIGTYPE_p_RuleType_t swig_types[76]
#define SWIGTYPE_p_SBMLConstructorException swig_types[77]
#define SWIGTYPE_p_SBMLConverter swig_types[78]
#define SWIGTYPE_p_SBMLConverterRegistry swig_types[79]
#define SWIGTYPE_p_SBMLDocument swig_types[80]
#define SWIGTYPE_p_SBMLDocumentPlugin swig_types[81]
#define SWIGTYPE_p_SBMLError swig_types[82]
#define SWIGTYPE_p_SBMLErrorCategory_t swig_types[83]
#define SWIGTYPE_p_SBMLErrorCode_t swig_types[84]
#define SWIGTYPE_p_SBMLErrorLog swig_types[85]
#define SWIGTYPE_p_SBMLErrorSeverity_t swig_types[86]
#define SWIGTYPE_p_SBMLExtension swig_types[87]
#define SWIGTYPE_p_SBMLExtensionException swig_types[88]
#define SWIGTYPE_p_SBMLExtensionRegistry swig_types[89]
#define SWIGTYPE_p_SBMLExternalValidator swig_types[90]
#define SWIGTYPE_p_SBMLFunctionDefinitionConverter swig_types[91]
#define SWIGTYPE_p_SBMLIdConverter swig_types[92]
#define SWIGTYPE_p_SBMLInferUnitsConverter swig_types[93]
#define SWIGTYPE_p_SBMLInitialAssignmentConverter swig_types[94]
#define SWIGTYPE_p_SBMLLevel1Version1Converter swig_types[95]
#define SWIGTYPE_p_SBMLLevelVersionConverter swig_types[96]
#define SWIGTYPE_p_SBMLLocalParameterConverter swig_types[97]
#define SWIGTYPE_p_SBMLNamespaces swig_types[98]
#define SWIGTYPE_p_SBMLReactionConverter swig_types[99]
#define SWIGTYPE_p_SBMLReader swig_types[100]
#define SWIGTYPE_p_SBMLRuleConverter swig_types[101]
#define SWIGTYPE_p_SBMLStripPackageConverter swig_types[102]
#define SWIGTYPE_p_SBMLTransforms swig_types[103]
#define SWIGTYPE_p_SBMLTypeCode_t swig_types[104]
#define SWIGTYPE_p_SBMLUnitsConverter swig_types[105]
#define SWIGTYPE_p_SBMLValidator swig_types[106]
#define SWIGTYPE_p_SBMLWriter swig_types[107]
#define SWIGTYPE_p_SBO swig_types[108]
#define SWIGTYPE_p_SBase swig_types[109]
#define SWIGTYPE_p_SBaseExtensionPoint swig_types[110]
#define SWIGTYPE_p_SBasePlugin swig_types[111]
#define SWIGTYPE_p_SBasePluginCreatorBase swig_types[112]
#define SWIGTYPE_p_SimpleSpeciesReference swig_types[113]
#define SWIGTYPE_p_Species swig_types[114]
#define SWIGTYPE_p_SpeciesReference swig_types[115]
#define SWIGTYPE_p_SpeciesType swig_types[116]
#define SWIGTYPE_p_StoichiometryMath swig_types[117]
#define SWIGTYPE_p_StringBuffer_t swig_types[118]
#define SWIGTYPE_p_SupportedPackageURIList swig_types[119]
#define SWIGTYPE_p_SupportedPackageURIListIter swig_types[120]
#define SWIGTYPE_p_SyntaxChecker swig_types[121]
#define SWIGTYPE_p_Trigger swig_types[122]
#define SWIGTYPE_p_Unit swig_types[123]
#define SWIGTYPE_p_UnitDefinition swig_types[124]
#define SWIGTYPE_p_UnitFormulaFormatter swig_types[125]
#define SWIGTYPE_p_UnitKind_t swig_types[126]
#define SWIGTYPE_p_XMLAttributes swig_types[127]
#define SWIGTYPE_p_XMLConstructorException swig_types[128]
#define SWIGTYPE_p_XMLError swig_types[129]
#define SWIGTYPE_p_XMLErrorCategory_t swig_types[130]
#define SWIGTYPE_p_XMLErrorCode_t swig_types[131]
#define SWIGTYPE_p_XMLErrorLog swig_types[132]
#define SWIGTYPE_p_XMLErrorSeverityOverride_t swig_types[133]
#define SWIGTYPE_p_XMLErrorSeverity_t swig_types[134]
#define SWIGTYPE_p_XMLInputStream swig_types[135]
#define SWIGTYPE_p_XMLNamespaces swig_types[136]
#define SWIGTYPE_p_XMLNode swig_types[137]
#define SWIGTYPE_p_XMLOutputFileStream swig_types[138]
#define SWIGTYPE_p_XMLOutputStream swig_types[139]
#define SWIGTYPE_p_XMLOutputStringStream swig_types[140]
#define SWIGTYPE_p_XMLOwningOutputFileStream swig_types[141]
#define SWIGTYPE_p_XMLOwningOutputStringStream swig_types[142]
#define SWIGTYPE_p_XMLToken swig_types[143]
#define SWIGTYPE_p_XMLTriple swig_types[144]
#define SWIGTYPE_p_allocator_type swig_types[145]
#define SWIGTYPE_p_char swig_types[146]
#define SWIGTYPE_p_char_type swig_types[147]
#define SWIGTYPE_p_const_iterator swig_types[148]
#define SWIGTYPE_p_const_reference swig_types[149]
#define SWIGTYPE_p_difference_type swig_types[150]
#define SWIGTYPE_p_int_type swig_types[151]
#define SWIGTYPE_p_iterator swig_types[152]
#define SWIGTYPE_p_off_type swig_types[153]
#define SWIGTYPE_p_p_PyObject swig_types[154]
#define SWIGTYPE_p_pos_type swig_types[155]
#define SWIGTYPE_p_reference swig_types[156]
#define SWIGTYPE_p_size_type swig_types[157]
#define SWIGTYPE_p_state_type swig_types[158]
#define SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t swig_types[159]
#define SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[160]
#define SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[161]
#define SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t swig_types[162]
#define SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[163]
#define SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator swig_types[164]
#define SWIGTYPE_p_std__invalid_argument swig_types[165]
#define SWIGTYPE_p_std__ios_base__openmode swig_types[166]
#define SWIGTYPE_p_std__multimapT_int_int_t swig_types[167]
#define SWIGTYPE_p_std__multimapT_int_int_t__iterator swig_types[168]
#define SWIGTYPE_p_std__pairT_std__multimapT_int_int_t__iterator_std__multimapT_int_int_t__iterator_t swig_types[169]
#define SWIGTYPE_p_std__stringstream swig_types[170]
#define SWIGTYPE_p_std__vectorT_ASTBasePlugin_p_t swig_types[171]
#define SWIGTYPE_p_std__vectorT_XMLError_p_t swig_types[172]
#define SWIGTYPE_p_std__vectorT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t swig_types[173]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t swig_types[174]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t__iterator swig_types[175]
#define SWIGTYPE_p_std__vectorT_unsigned_int_t swig_types[176]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[177]
#define SWIGTYPE_p_value_type swig_types[178]
static swig_type_info *swig_types[180];
static swig_module_info swig_module = {swig_types, 179, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

/* -------- TYPES TABLE (END) -------- */

#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery

/*-----------------------------------------------
              @(target):= _libsbml.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit__libsbml

#else
#  define SWIG_init    init_libsbml

#endif
#define SWIG_name    "_libsbml"

#define SWIGVERSION 0x040002 
#define SWIG_VERSION SWIGVERSION


#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 


#include <stdexcept>


namespace swig {
  class SwigPtr_PyObject {
  protected:
    PyObject *_obj;

  public:
    SwigPtr_PyObject() :_obj(0)
    {
    }

    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XINCREF(_obj);      
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        Py_XINCREF(_obj);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XINCREF(item._obj);
      Py_XDECREF(_obj);
      _obj = item._obj;
      SWIG_PYTHON_THREAD_END_BLOCK;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XDECREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    operator PyObject *() const
    {
      return _obj;
    }

    PyObject *operator->() const
    {
      return _obj;
    }
  };
}


namespace swig {
  struct SwigVar_PyObject : SwigPtr_PyObject {
    SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
    
    SwigVar_PyObject & operator = (PyObject* obj)
    {
      Py_XDECREF(_obj);
      _obj = obj;
      return *this;      
    }
  };
}


#include "libsbml.h"

LIBSBML_CPP_NAMESPACE_USE

#include "../swig/libsbml-packages.h"
	
#include "local.cpp"


#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
#   define LLONG_MAX __LONG_LONG_MAX__
#   define LLONG_MIN (-LLONG_MAX - 1LL)
#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif


SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
  int res = SWIG_TypeError;
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AsDouble(obj);
    return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
  } else if (PyInt_Check(obj)) {
    if (val) *val = (double) PyInt_AsLong(obj);
    return SWIG_OK;
#endif
  } else if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    double d = PyFloat_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = d;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      long v = PyLong_AsLong(obj);
      if (!PyErr_Occurred()) {
	if (val) *val = v;
	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
      } else {
	PyErr_Clear();
      }
    }
  }
#endif
  return res;
}


#include <float.h>


#include <math.h>


SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
  double x = *d;
  if ((min <= x && x <= max)) {
   double fx = floor(x);
   double cx = ceil(x);
   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    long v = PyInt_AsLong(obj);
    if (v >= 0) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      return SWIG_OverflowError;
    }
  } else
#endif
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
	if (val) *val = (unsigned long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject*
  SWIG_From_unsigned_SS_int  (unsigned int value)
{
  return PyInt_FromSize_t((size_t) value);
}


#include <iostream>

#if PY_VERSION_HEX >= 0x03020000
# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
#else
# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
#endif


#include <typeinfo>
#include <stdexcept>


#if defined(__GNUC__)
#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
#     define SWIG_STD_NOMODERN_STL
#  endif
#endif


#include <string>


#include <stddef.h>


namespace swig {
  struct stop_iteration {
  };

  struct SwigPyIterator {
  private:
    SwigPtr_PyObject _seq;

  protected:
    SwigPyIterator(PyObject *seq) : _seq(seq)
    {
    }
      
  public:
    virtual ~SwigPyIterator() {}

    // Access iterator method, required by Python
    virtual PyObject *value() const = 0;

    // Forward iterator method, required by Python
    virtual SwigPyIterator *incr(size_t n = 1) = 0;
    
    // Backward iterator method, very common in C++, but not required in Python
    virtual SwigPyIterator *decr(size_t /*n*/ = 1)
    {
      throw stop_iteration();
    }

    // Random access iterator methods, but not required in Python
    virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
    {
      throw std::invalid_argument("operation not supported");
    }

    virtual bool equal (const SwigPyIterator &/*x*/) const
    {
      throw std::invalid_argument("operation not supported");
    }
    
    // C++ common/needed methods
    virtual SwigPyIterator *copy() const = 0;

    PyObject *next()     
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
      PyObject *obj = value();
      incr();       
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
      return obj;     
    }

    /* Make an alias for Python 3.x */
    PyObject *__next__()
    {
      return next();
    }

    PyObject *previous()
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
      decr();
      PyObject *obj = value();
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads       
      return obj;
    }

    SwigPyIterator *advance(ptrdiff_t n)
    {
      return  (n > 0) ?  incr(n) : decr(-n);
    }
      
    bool operator == (const SwigPyIterator& x)  const
    {
      return equal(x);
    }
      
    bool operator != (const SwigPyIterator& x) const
    {
      return ! operator==(x);
    }
      
    SwigPyIterator& operator += (ptrdiff_t n)
    {
      return *advance(n);
    }

    SwigPyIterator& operator -= (ptrdiff_t n)
    {
      return *advance(-n);
    }
      
    SwigPyIterator* operator + (ptrdiff_t n) const
    {
      return copy()->advance(n);
    }

    SwigPyIterator* operator - (ptrdiff_t n) const
    {
      return copy()->advance(-n);
    }
      
    ptrdiff_t operator - (const SwigPyIterator& x) const
    {
      return x.distance(*this);
    }
      
    static swig_type_info* descriptor() {
      static int init = 0;
      static swig_type_info* desc = 0;
      if (!init) {
	desc = SWIG_TypeQuery("swig::SwigPyIterator *");
	init = 1;
      }	
      return desc;
    }    
  };

#if defined(SWIGPYTHON_BUILTIN)
  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
  {
    Py_INCREF(pyself);
    return pyself;
  }
#endif
}


#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
#  define SWIG_LONG_LONG_AVAILABLE
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
      if (val) *val = (unsigned long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    unsigned long long v;
    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  }
#endif
  return res;
}


  #define SWIG_From_long   PyInt_FromLong 


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_long_SS_long  (long long value)
{
  return ((value < LONG_MIN) || (value > LONG_MAX)) ?
    PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERNINLINE PyObject *
SWIG_From_ptrdiff_t  (ptrdiff_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    return SWIG_From_long  (static_cast< long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
    return SWIG_From_long_SS_long  (static_cast< long long >(value));
  }
#endif
}


SWIGINTERNINLINE PyObject*
  SWIG_From_bool  (bool value)
{
  return PyBool_FromLong(value ? 1 : 0);
}


SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else
#endif
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    long v = PyInt_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    long long v = PyLong_AsLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    long v;
    res = SWIG_AsVal_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    const double mant_min = -mant_max;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
      if (val) *val = (long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    long v;
    res = SWIG_AsVal_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
    long long v;
    res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
  }
#endif
  return res;
}


#include <algorithm>


SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERNINLINE PyObject *
SWIG_From_size_t  (size_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
  }
#endif
}


SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static int init = 0;
  static swig_type_info* info = 0;
  if (!init) {
    info = SWIG_TypeQuery("_p_char");
    init = 1;
  }
  return info;
}


SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  if (PyBytes_Check(obj))
#else
  if (PyUnicode_Check(obj))
#endif
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
    int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (!alloc && cptr) {
        /* We can't allow converting without allocation, since the internal
           representation of string in Python 3 is UCS-2/UCS-4 but we require
           a UTF-8 representation.
           TODO(bhy) More detailed explanation */
        return SWIG_RuntimeError;
    }
    obj = PyUnicode_AsUTF8String(obj);
    if (!obj)
      return SWIG_TypeError;
    if (alloc)
      *alloc = SWIG_NEWOBJ;
#endif
    if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#else
    if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#endif
    if (cptr) {
      if (alloc) {
	if (*alloc == SWIG_NEWOBJ) {
	  *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
	  *alloc = SWIG_NEWOBJ;
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      } else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
	*cptr = PyBytes_AsString(obj);
#else
	assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
	*cptr = SWIG_Python_str_AsChar(obj);
        if (!*cptr)
          ret = SWIG_TypeError;
#endif
      }
    }
    if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    Py_XDECREF(obj);
#endif
    return ret;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (!obj)
        return SWIG_TypeError;
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        }
        if (psize) *psize = len + 1;

        Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        Py_XDECREF(obj);
      }
    }
#endif
#endif

    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *) vptr;
	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    /* special case of single char conversion when we don't need space for NUL */
    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize*sizeof(char));
	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
	delete[] cptr;
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) delete[] cptr;
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
	if (val) *val = static_cast< char >(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > INT_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
      return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#else
      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
#endif
#else
      return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


SWIGINTERNINLINE PyObject *
SWIG_From_char  (char c) 
{ 
  return SWIG_FromCharPtrAndSize(&c,1);
}


namespace swig {
  template <class Type>
  struct noconst_traits {
    typedef Type noconst_type;
  };

  template <class Type>
  struct noconst_traits<const Type> {
    typedef Type noconst_type;
  };

  /*
    type categories
  */
  struct pointer_category { };
  struct value_category { };

  /*
    General traits that provides type_name and type_info
  */
  template <class Type> struct traits { };

  template <class Type>
  inline const char* type_name() {
    return traits<typename noconst_traits<Type >::noconst_type >::type_name();
  }

  template <class Type> struct traits_info {
    static swig_type_info *type_query(std::string name) {
      name += " *";
      return SWIG_TypeQuery(name.c_str());
    }
    static swig_type_info *type_info() {
      static swig_type_info *info = type_query(type_name<Type>());
      return info;
    }
  };

  /*
    Partial specialization for pointers (traits_info)
  */
  template <class Type> struct traits_info<Type *> {
    static swig_type_info *type_query(std::string name) {
      name += " *";
      return SWIG_TypeQuery(name.c_str());
    }
    static swig_type_info *type_info() {
      static swig_type_info *info = type_query(type_name<Type>());
      return info;
    }
  };

  template <class Type>
  inline swig_type_info *type_info() {
    return traits_info<Type>::type_info();
  }

  /*
    Partial specialization for pointers (traits)
  */
  template <class Type> struct traits <Type *> {
    typedef pointer_category category;
    static std::string make_ptr_name(const char* name) {
      std::string ptrname = name;
      ptrname += " *";
      return ptrname;
    }
    static const char* type_name() {
      static std::string name = make_ptr_name(swig::type_name<Type>());
      return name.c_str();
    }
  };

  template <class Type, class Category>
  struct traits_as { };

  template <class Type, class Category>
  struct traits_check { };

}


namespace swig {  
  /*
    Traits that provides the from method
  */
  template <class Type> struct traits_from_ptr {
    static PyObject *from(Type *val, int owner = 0) {
      return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
    }
  };

  template <class Type> struct traits_from {
    static PyObject *from(const Type& val) {
      return traits_from_ptr<Type>::from(new Type(val), 1);
    }
  };

  template <class Type> struct traits_from<Type *> {
    static PyObject *from(Type* val) {
      return traits_from_ptr<Type>::from(val, 0);
    }
  };

  template <class Type> struct traits_from<const Type *> {
    static PyObject *from(const Type* val) {
      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
    }
  };


  template <class Type>
  inline PyObject *from(const Type& val) {
    return traits_from<Type>::from(val);
  }

  template <class Type>
  inline PyObject *from_ptr(Type* val, int owner) {
    return traits_from_ptr<Type>::from(val, owner);
  }

  /*
    Traits that provides the asval/as/check method
  */
  template <class Type>
  struct traits_asptr {   
    static int asptr(PyObject *obj, Type **val) {
      int res = SWIG_ERROR;
      swig_type_info *descriptor = type_info<Type>();
      if (val) {
        Type *p = 0;
        int newmem = 0;
        res = descriptor ? SWIG_ConvertPtrAndOwn(obj, (void **)&p, descriptor, 0, &newmem) : SWIG_ERROR;
        if (SWIG_IsOK(res)) {
          if (newmem & SWIG_CAST_NEW_MEMORY) {
            res |= SWIG_NEWOBJMASK;
          }
          *val = p;
        }
      } else {
        res = descriptor ? SWIG_ConvertPtr(obj, 0, descriptor, 0) : SWIG_ERROR;
      }
      return res;
    }
  }; 

  template <class Type>
  inline int asptr(PyObject *obj, Type **vptr) {
    return traits_asptr<Type>::asptr(obj, vptr);
  }

  template <class Type> 
  struct traits_asval {
    static int asval(PyObject *obj, Type *val) {
      if (val) {
	Type *p = 0;
	int res = traits_asptr<Type>::asptr(obj, &p);
	if (!SWIG_IsOK(res)) return res;	
	if (p) {
	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
	  *(const_cast<noconst_type*>(val)) = *p;
	  if (SWIG_IsNewObj(res)){
	    delete p;
	    res = SWIG_DelNewMask(res);
	  }
	  return res;
	} else {
	  return SWIG_ERROR;
	}
      } else {
	return traits_asptr<Type>::asptr(obj, (Type **)(0));
      }
    }
  };

  template <class Type> struct traits_asval<Type*> {
    static int asval(PyObject *obj, Type **val) {
      if (val) {
        typedef typename noconst_traits<Type>::noconst_type noconst_type;
        noconst_type *p = 0;
        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
        if (SWIG_IsOK(res)) {
          *(const_cast<noconst_type**>(val)) = p;
	}
	return res;
      } else {
	return traits_asptr<Type>::asptr(obj, (Type **)(0));
      }
    }
  };
  
  template <class Type>
  inline int asval(PyObject *obj, Type *val) {
    return traits_asval<Type>::asval(obj, val);
  }

  template <class Type> 
  struct traits_as<Type, value_category> {
    static Type as(PyObject *obj) {
      Type v;
      int res = asval(obj, &v);
      if (!obj || !SWIG_IsOK(res)) {
	if (!PyErr_Occurred()) {
	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
      return v;
    }
  };

  template <class Type> 
  struct traits_as<Type, pointer_category> {
    static Type as(PyObject *obj) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res) && v) {
	if (SWIG_IsNewObj(res)) {
	  Type r(*v);
	  delete v;
	  return r;
	} else {
	  return *v;
	}
      } else {
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
    }
  };

  template <class Type> 
  struct traits_as<Type*, pointer_category> {
    static Type* as(PyObject *obj) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res)) {
	return v;
      } else {
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
    }
  };
    
  template <class Type>
  inline Type as(PyObject *obj) {
    return traits_as<Type, typename traits<Type>::category>::as(obj);
  }

  template <class Type> 
  struct traits_check<Type, value_category> {
    static bool check(PyObject *obj) {
      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
      return SWIG_IsOK(res) ? true : false;
    }
  };

  template <class Type> 
  struct traits_check<Type, pointer_category> {
    static bool check(PyObject *obj) {
      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
      return SWIG_IsOK(res) ? true : false;
    }
  };

  template <class Type>
  inline bool check(PyObject *obj) {
    return traits_check<Type, typename traits<Type>::category>::check(obj);
  }
}


namespace swig {
  template <> struct traits< char > {
    typedef value_category category;
    static const char* type_name() { return"char"; }
  };
  template <>  struct traits_asval< char > {
    typedef char value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_char (obj, val);
    }
  };
  template <>  struct traits_from< char > {
    typedef char value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_char  (val);
    }
  };
}





SWIGINTERN int
SWIG_AsPtr_std_basic_string_Sl_char_Sg_ (PyObject* obj, std::string **val) {
  static swig_type_info* string_info = SWIG_TypeQuery("std::basic_string<char> *");
  std::string *vptr;
  if (SWIG_IsOK(SWIG_ConvertPtr(obj, (void**)&vptr, string_info, 0))) {
    if (val) *val = vptr;
    return SWIG_OLDOBJ;
  } else {
    PyErr_Clear();
    char* buf = 0 ; size_t size = 0; int alloc = 0;
    if (SWIG_IsOK(SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc))) {
      if (buf) {
	if (val) *val = new std::string(buf, size - 1);
	if (alloc == SWIG_NEWOBJ) delete[] buf;
	return SWIG_NEWOBJ;
      } else {
        if (val) *val = 0;
        return SWIG_OLDOBJ;
      }
    }
    return SWIG_ERROR;
  }
}


SWIGINTERNINLINE PyObject * 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}


SWIGINTERNINLINE PyObject*
  SWIG_From_std_basic_string_Sl_char_Sg_  (const std::string& s) {
    return SWIG_FromCharPtrAndSize(s.data(), s.size());
  }

SWIGINTERN std::basic_string< char >::iterator std_basic_string_Sl_char_Sg__erase__SWIG_3(std::basic_string< char > *self,std::basic_string< char >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::basic_string< char >::iterator std_basic_string_Sl_char_Sg__erase__SWIG_4(std::basic_string< char > *self,std::basic_string< char >::iterator first,std::basic_string< char >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::basic_string< char >::iterator std_basic_string_Sl_char_Sg__insert__SWIG_4(std::basic_string< char > *self,std::basic_string< char >::iterator pos,std::basic_string< char >::value_type x){ return self->insert(pos, x); }
SWIGINTERN void std_basic_string_Sl_char_Sg__insert__SWIG_5(std::basic_string< char > *self,std::basic_string< char >::iterator pos,std::basic_string< char >::size_type n,std::basic_string< char >::value_type x){ self->insert(pos, n, x); }

#include <functional>

namespace std {
  template <>
  struct less <PyObject *>
  {
    bool
    operator()(PyObject * v, PyObject *w) const
    { 
      bool res;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
      /* This may fall into a case of inconsistent
               eg. ObjA > ObjX > ObjB
               but ObjA < ObjB
      */
      if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
      {
        /* Objects can't be compared, this mostly occurred in Python 3.0 */
        /* Compare their ptr directly for a workaround */
        res = (v < w);
        PyErr_Clear();
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return res;
    }
  };

  template <>
  struct less <swig::SwigPtr_PyObject>
  {
    bool
    operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
    {
      return std::less<PyObject *>()(v, w);
    }
  };

  template <>
  struct less <swig::SwigVar_PyObject>
  {
    bool
    operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
    {
      return std::less<PyObject *>()(v, w);
    }
  };

}

namespace swig {
  template <> struct traits<PyObject *> {
    typedef value_category category;
    static const char* type_name() { return "PyObject *"; }
  };  

  template <>  struct traits_asval<PyObject * > {   
    typedef PyObject * value_type;
    static int asval(PyObject *obj, value_type *val) {
      if (val) *val = obj;
      return SWIG_OK;
    }
  };

  template <> 
  struct traits_check<PyObject *, value_category> {
    static bool check(PyObject *) {
      return true;
    }
  };

  template <>  struct traits_from<PyObject *> {
    typedef PyObject * value_type;
    static PyObject *from(const value_type& val) {
      Py_XINCREF(val);
      return val;
    }
  };
  
}

namespace swig {
  template <class Difference>
  inline size_t
  check_index(Difference i, size_t size, bool insert = false) {
    if ( i < 0 ) {
      if ((size_t) (-i) <= size)
	return (size_t) (i + size);
    } else if ( (size_t) i < size ) {
      return (size_t) i;
    } else if (insert && ((size_t) i == size)) {
      return size;
    }
    throw std::out_of_range("index out of range");
  }

  template <class Difference>
  void
  slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
    if (step == 0) {
      throw std::invalid_argument("slice step cannot be zero");
    } else if (step > 0) {
      // Required range: 0 <= i < size, 0 <= j < size, i <= j
      if (i < 0) {
        ii = 0;
      } else if (i < (Difference)size) {
        ii = i;
      } else if (insert && (i >= (Difference)size)) {
        ii = (Difference)size;
      }
      if (j < 0) {
        jj = 0;
      } else {
        jj = (j < (Difference)size) ? j : (Difference)size;
      }
      if (jj < ii)
        jj = ii;
    } else {
      // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j
      if (i < -1) {
        ii = -1;
      } else if (i < (Difference) size) {
        ii = i;
      } else if (i >= (Difference)(size-1)) {
        ii = (Difference)(size-1);
      }
      if (j < -1) {
        jj = -1;
      } else {
        jj = (j < (Difference)size ) ? j : (Difference)(size-1);
      }
      if (ii < jj)
        ii = jj;
    }
  }

  template <class Sequence, class Difference>
  inline typename Sequence::iterator
  getpos(Sequence* self, Difference i)  {
    typename Sequence::iterator pos = self->begin();
    std::advance(pos, check_index(i,self->size()));
    return pos;
  }

  template <class Sequence, class Difference>
  inline typename Sequence::const_iterator
  cgetpos(const Sequence* self, Difference i)  {
    typename Sequence::const_iterator pos = self->begin();
    std::advance(pos, check_index(i,self->size()));
    return pos;
  }

  template <class Sequence>
  inline void
  erase(Sequence* seq, const typename Sequence::iterator& position) {
    seq->erase(position);
  }

  template <class Sequence>
  struct traits_reserve {
    static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) {
      // This should be specialized for types that support reserve
    }
  };

  template <class Sequence, class Difference>
  inline Sequence*
  getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
    typename Sequence::size_type size = self->size();
    Difference ii = 0;
    Difference jj = 0;
    swig::slice_adjust(i, j, step, size, ii, jj);

    if (step > 0) {
      typename Sequence::const_iterator sb = self->begin();
      typename Sequence::const_iterator se = self->begin();
      std::advance(sb,ii);
      std::advance(se,jj);
      if (step == 1) {
        return new Sequence(sb, se);
      } else {
        Sequence *sequence = new Sequence();
        swig::traits_reserve<Sequence>::reserve(*sequence, (jj - ii + step - 1) / step);
        typename Sequence::const_iterator it = sb;
        while (it!=se) {
          sequence->push_back(*it);
          for (Py_ssize_t c=0; c<step && it!=se; ++c)
            it++;
        }
        return sequence;
      } 
    } else {
      Sequence *sequence = new Sequence();
      swig::traits_reserve<Sequence>::reserve(*sequence, (ii - jj - step - 1) / -step);
      typename Sequence::const_reverse_iterator sb = self->rbegin();
      typename Sequence::const_reverse_iterator se = self->rbegin();
      std::advance(sb,size-ii-1);
      std::advance(se,size-jj-1);
      typename Sequence::const_reverse_iterator it = sb;
      while (it!=se) {
        sequence->push_back(*it);
        for (Py_ssize_t c=0; c<-step && it!=se; ++c)
          it++;
      }
      return sequence;
    }
  }

  template <class Sequence, class Difference, class InputSeq>
  inline void
  setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
    typename Sequence::size_type size = self->size();
    Difference ii = 0;
    Difference jj = 0;
    swig::slice_adjust(i, j, step, size, ii, jj, true);
    if (step > 0) {
      if (step == 1) {
        size_t ssize = jj - ii;
        if (ssize <= is.size()) {
          // expanding/staying the same size
          swig::traits_reserve<Sequence>::reserve(*self, self->size() - ssize + is.size());
          typename Sequence::iterator sb = self->begin();
          typename InputSeq::const_iterator isit = is.begin();
          std::advance(sb,ii);
          std::advance(isit, jj - ii);
          self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
        } else {
          // shrinking
          typename Sequence::iterator sb = self->begin();
          typename Sequence::iterator se = self->begin();
          std::advance(sb,ii);
          std::advance(se,jj);
          self->erase(sb,se);
          sb = self->begin();
          std::advance(sb,ii);
          self->insert(sb, is.begin(), is.end());
        }
      } else {
        size_t replacecount = (jj - ii + step - 1) / step;
        if (is.size() != replacecount) {
          char msg[1024];
          sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
          throw std::invalid_argument(msg);
        }
        typename Sequence::const_iterator isit = is.begin();
        typename Sequence::iterator it = self->begin();
        std::advance(it,ii);
        for (size_t rc=0; rc<replacecount && it != self->end(); ++rc) {
          *it++ = *isit++;
          for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
            it++;
        }
      }
    } else {
      size_t replacecount = (ii - jj - step - 1) / -step;
      if (is.size() != replacecount) {
        char msg[1024];
        sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
        throw std::invalid_argument(msg);
      }
      typename Sequence::const_iterator isit = is.begin();
      typename Sequence::reverse_iterator it = self->rbegin();
      std::advance(it,size-ii-1);
      for (size_t rc=0; rc<replacecount && it != self->rend(); ++rc) {
        *it++ = *isit++;
        for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
          it++;
      }
    }
  }

  template <class Sequence, class Difference>
  inline void
  delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
    typename Sequence::size_type size = self->size();
    Difference ii = 0;
    Difference jj = 0;
    swig::slice_adjust(i, j, step, size, ii, jj, true);
    if (step > 0) {
      typename Sequence::iterator sb = self->begin();
      std::advance(sb,ii);
      if (step == 1) {
        typename Sequence::iterator se = self->begin();
        std::advance(se,jj);
        self->erase(sb,se);
      } else {
        typename Sequence::iterator it = sb;
        size_t delcount = (jj - ii + step - 1) / step;
        while (delcount) {
          it = self->erase(it);
          for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
            it++;
          delcount--;
        }
      }
    } else {
      typename Sequence::reverse_iterator sb = self->rbegin();
      std::advance(sb,size-ii-1);
      typename Sequence::reverse_iterator it = sb;
      size_t delcount = (ii - jj - step - 1) / -step;
      while (delcount) {
        it = typename Sequence::reverse_iterator(self->erase((++it).base()));
        for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
          it++;
        delcount--;
      }
    }
  }
}


#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
#  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
#    define SWIG_STD_NOITERATOR_TRAITS_STL
#  endif
#endif

#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
#include <iterator>
#else
namespace std {
  template <class Iterator>
  struct iterator_traits {
    typedef ptrdiff_t difference_type;
    typedef typename Iterator::value_type value_type;
  };

  template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
  struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
    typedef Distance difference_type;
    typedef T value_type;
  };

  template <class T>
  struct iterator_traits<T*> {
    typedef T value_type;
    typedef ptrdiff_t difference_type;
  };

  template<typename _InputIterator>
  inline typename iterator_traits<_InputIterator>::difference_type
  distance(_InputIterator __first, _InputIterator __last)
  {
    typename iterator_traits<_InputIterator>::difference_type __n = 0;
    while (__first != __last) {
      ++__first; ++__n;
    }
    return __n;
  }
}
#endif


namespace swig {
  template<typename OutIterator>
  class SwigPyIterator_T :  public SwigPyIterator
  {
  public:
    typedef OutIterator out_iterator;
    typedef typename std::iterator_traits<out_iterator>::value_type value_type;    
    typedef SwigPyIterator_T<out_iterator> self_type;

    SwigPyIterator_T(out_iterator curr, PyObject *seq)
      : SwigPyIterator(seq), current(curr)
    {
    }

    const out_iterator& get_current() const
    {
      return current;
    }

    
    bool equal (const SwigPyIterator &iter) const
    {
      const self_type *iters = dynamic_cast<const self_type *>(&iter);
      if (iters) {
	return (current == iters->get_current());
      } else {
	throw std::invalid_argument("bad iterator type");
      }
    }
    
    ptrdiff_t distance(const SwigPyIterator &iter) const
    {
      const self_type *iters = dynamic_cast<const self_type *>(&iter);
      if (iters) {
	return std::distance(current, iters->get_current());
      } else {
	throw std::invalid_argument("bad iterator type");
      }
    }    
    
  protected:
    out_iterator current;
  };
  
  template <class ValueType>
  struct from_oper 
  {
    typedef const ValueType& argument_type;
    typedef PyObject *result_type;
    result_type operator()(argument_type v) const
    {
      return swig::from(v);
    }
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyForwardIteratorOpen_T :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;
    typedef SwigPyForwardIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyForwardIteratorOpen_T(out_iterator curr, PyObject *seq)
      : SwigPyIterator_T<OutIterator>(curr, seq)
    {
    }
    
    PyObject *value() const {
      return from(static_cast<const value_type&>(*(base::current)));
    }
    
    SwigPyIterator *copy() const
    {
      return new self_type(*this);
    }

    SwigPyIterator *incr(size_t n = 1)
    {
      while (n--) {
	++base::current;
      }
      return this;
    }

  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyIteratorOpen_T :  public SwigPyForwardIteratorOpen_T<OutIterator, ValueType, FromOper>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;
    typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
      : SwigPyForwardIteratorOpen_T<OutIterator>(curr, seq)
    {
    }

    SwigPyIterator *decr(size_t n = 1)
    {
      while (n--) {
	--base::current;
      }
      return this;
    }
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyForwardIteratorClosed_T :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;    
    typedef SwigPyForwardIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyForwardIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
      : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
    {
    }
    
    PyObject *value() const {
      if (base::current == end) {
	throw stop_iteration();
      } else {
	return from(static_cast<const value_type&>(*(base::current)));
      }
    }
    
    SwigPyIterator *copy() const
    {
      return new self_type(*this);
    }

    SwigPyIterator *incr(size_t n = 1)
    {
      while (n--) {
	if (base::current == end) {
	  throw stop_iteration();
	} else {
	  ++base::current;
	}
      }
      return this;
    }

  protected:
    out_iterator begin;
    out_iterator end;
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyIteratorClosed_T :  public SwigPyForwardIteratorClosed_T<OutIterator,ValueType,FromOper>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;
    typedef SwigPyForwardIteratorClosed_T<OutIterator, ValueType, FromOper> base0;
    typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
      : SwigPyForwardIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
    {
    }

    SwigPyIterator *decr(size_t n = 1)
    {
      while (n--) {
	if (base::current == base0::begin) {
	  throw stop_iteration();
	} else {
	  --base::current;
	}
      }
      return this;
    }
  };


  template<typename OutIter>
  inline SwigPyIterator*
  make_output_forward_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
  {
    return new SwigPyForwardIteratorClosed_T<OutIter>(current, begin, end, seq);
  }

  template<typename OutIter>
  inline SwigPyIterator*
  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
  {
    return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
  }

  template<typename OutIter>
  inline SwigPyIterator*
  make_output_forward_iterator(const OutIter& current, PyObject *seq = 0)
  {
    return new SwigPyForwardIteratorOpen_T<OutIter>(current, seq);
  }

  template<typename OutIter>
  inline SwigPyIterator*
  make_output_iterator(const OutIter& current, PyObject *seq = 0)
  {
    return new SwigPyIteratorOpen_T<OutIter>(current, seq);
  }

}


namespace swig
{
  template <class T>
  struct SwigPySequence_Ref
  {
    SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
      : _seq(seq), _index(index)
    {
    }
    
    operator T () const
    {
      swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
      try {
	return swig::as<T>(item);
      } catch (const std::invalid_argument& e) {
	char msg[1024];
	sprintf(msg, "in sequence element %d ", (int)_index);
	if (!PyErr_Occurred()) {
	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
	}
	SWIG_Python_AddErrorMsg(msg);
	SWIG_Python_AddErrorMsg(e.what());
	throw;
      }
    }

    SwigPySequence_Ref& operator=(const T& v)
    {
      PySequence_SetItem(_seq, _index, swig::from<T>(v));
      return *this;
    }

  private:
    PyObject* _seq;
    Py_ssize_t _index;
  };

  template <class T>
  struct SwigPySequence_ArrowProxy
  {
    SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
    const T* operator->() const { return &m_value; }
    operator const T*() const { return &m_value; }
    T m_value;
  };

  template <class T, class Reference >
  struct SwigPySequence_InputIterator
  {
    typedef SwigPySequence_InputIterator<T, Reference > self;

    typedef std::random_access_iterator_tag iterator_category;
    typedef Reference reference;
    typedef T value_type;
    typedef T* pointer;
    typedef Py_ssize_t difference_type;

    SwigPySequence_InputIterator()
    {
    }

    SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
      : _seq(seq), _index(index)
    {
    }

    reference operator*() const
    {
      return reference(_seq, _index);
    }

    SwigPySequence_ArrowProxy<T>
    operator->() const {
      return SwigPySequence_ArrowProxy<T>(operator*());
    }

    bool operator==(const self& ri) const
    {
      return (_index == ri._index) && (_seq == ri._seq);
    }

    bool operator!=(const self& ri) const
    {
      return !(operator==(ri));
    }

    self& operator ++ ()
    {
      ++_index;
      return *this;
    }

    self& operator -- ()
    {
      --_index;
      return *this;
    }

    self& operator += (difference_type n)
    {
      _index += n;
      return *this;
    }

    self operator +(difference_type n) const
    {
      return self(_seq, _index + n);
    }

    self& operator -= (difference_type n)
    {
      _index -= n;
      return *this;
    }

    self operator -(difference_type n) const
    {
      return self(_seq, _index - n);
    }

    difference_type operator - (const self& ri) const
    {
      return _index - ri._index;
    }

    bool operator < (const self& ri) const
    {
      return _index < ri._index;
    }

    reference
    operator[](difference_type n) const
    {
      return reference(_seq, _index + n);
    }

  private:
    PyObject* _seq;
    difference_type _index;
  };

  // STL container wrapper around a Python sequence
  template <class T>
  struct SwigPySequence_Cont
  {
    typedef SwigPySequence_Ref<T> reference;
    typedef const SwigPySequence_Ref<T> const_reference;
    typedef T value_type;
    typedef T* pointer;
    typedef Py_ssize_t difference_type;
    typedef size_t size_type;
    typedef const pointer const_pointer;
    typedef SwigPySequence_InputIterator<T, reference> iterator;
    typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;

    SwigPySequence_Cont(PyObject* seq) : _seq(0)
    {
      if (!PySequence_Check(seq)) {
	throw std::invalid_argument("a sequence is expected");
      }
      _seq = seq;
      Py_INCREF(_seq);
    }

    ~SwigPySequence_Cont()
    {
      Py_XDECREF(_seq);
    }

    size_type size() const
    {
      return static_cast<size_type>(PySequence_Size(_seq));
    }

    bool empty() const
    {
      return size() == 0;
    }

    iterator begin()
    {
      return iterator(_seq, 0);
    }

    const_iterator begin() const
    {
      return const_iterator(_seq, 0);
    }

    iterator end()
    {
      return iterator(_seq, size());
    }

    const_iterator end() const
    {
      return const_iterator(_seq, size());
    }

    reference operator[](difference_type n)
    {
      return reference(_seq, n);
    }

    const_reference operator[](difference_type n)  const
    {
      return const_reference(_seq, n);
    }

    bool check() const
    {
      Py_ssize_t s = size();
      for (Py_ssize_t i = 0; i < s; ++i) {
	swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
	if (!swig::check<value_type>(item))
	  return false;
      }
      return true;
    }

  private:
    PyObject* _seq;
  };

}

SWIGINTERN swig::SwigPyIterator *std_basic_string_Sl_char_Sg__iterator(std::basic_string< char > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_basic_string_Sl_char_Sg____nonzero__(std::basic_string< char > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_basic_string_Sl_char_Sg____bool__(std::basic_string< char > const *self){
      return !(self->empty());
    }
SWIGINTERN std::basic_string< char >::size_type std_basic_string_Sl_char_Sg____len__(std::basic_string< char > const *self){
      return self->size();
    }
SWIGINTERN std::basic_string< char,std::char_traits< char >,std::allocator< char > > *std_basic_string_Sl_char_Sg____getslice__(std::basic_string< char > *self,std::basic_string< char >::difference_type i,std::basic_string< char >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_basic_string_Sl_char_Sg____setslice____SWIG_0(std::basic_string< char > *self,std::basic_string< char >::difference_type i,std::basic_string< char >::difference_type j){
      swig::setslice(self, i, j, 1, std::basic_string< char,std::char_traits< char >,std::allocator< char > >());
    }
SWIGINTERN void std_basic_string_Sl_char_Sg____setslice____SWIG_1(std::basic_string< char > *self,std::basic_string< char >::difference_type i,std::basic_string< char >::difference_type j,std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_basic_string_Sl_char_Sg____delslice__(std::basic_string< char > *self,std::basic_string< char >::difference_type i,std::basic_string< char >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_basic_string_Sl_char_Sg____delitem____SWIG_0(std::basic_string< char > *self,std::basic_string< char >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::basic_string< char,std::char_traits< char >,std::allocator< char > > *std_basic_string_Sl_char_Sg____getitem____SWIG_0(std::basic_string< char > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::basic_string< char,std::char_traits< char >,std::allocator< char > >::difference_type id = i;
      std::basic_string< char,std::char_traits< char >,std::allocator< char > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_basic_string_Sl_char_Sg____setitem____SWIG_0(std::basic_string< char > *self,PySliceObject *slice,std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::basic_string< char,std::char_traits< char >,std::allocator< char > >::difference_type id = i;
      std::basic_string< char,std::char_traits< char >,std::allocator< char > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_basic_string_Sl_char_Sg____setitem____SWIG_1(std::basic_string< char > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::basic_string< char,std::char_traits< char >,std::allocator< char > >::difference_type id = i;
      std::basic_string< char,std::char_traits< char >,std::allocator< char > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_basic_string_Sl_char_Sg____delitem____SWIG_1(std::basic_string< char > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::basic_string< char,std::char_traits< char >,std::allocator< char > >::difference_type id = i;
      std::basic_string< char,std::char_traits< char >,std::allocator< char > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::basic_string< char >::value_type std_basic_string_Sl_char_Sg____getitem____SWIG_1(std::basic_string< char > *self,std::basic_string< char >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_basic_string_Sl_char_Sg____setitem____SWIG_2(std::basic_string< char > *self,std::basic_string< char >::difference_type i,std::basic_string< char >::value_type x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::basic_string< char,std::char_traits< char >,std::allocator< char > > *std_basic_string_Sl_char_Sg____add__(std::basic_string< char > *self,std::basic_string< char > const &v){
	std::basic_string< char,std::char_traits< char >,std::allocator< char > >* res = new std::basic_string< char,std::char_traits< char >,std::allocator< char > >(*self);
	*res += v;      
	return res;
      }
SWIGINTERN std::basic_string< char,std::char_traits< char >,std::allocator< char > > *std_basic_string_Sl_char_Sg____radd__(std::basic_string< char > *self,std::basic_string< char > const &v){
	std::basic_string< char,std::char_traits< char >,std::allocator< char > >* res = new std::basic_string< char,std::char_traits< char >,std::allocator< char > >(v);
	*res += *self;      
	return res;
      }
SWIGINTERN std::basic_string< char,std::char_traits< char >,std::allocator< char > > std_basic_string_Sl_char_Sg____str__(std::basic_string< char > *self){
	return *self;
      }
SWIGINTERN std::basic_ostream< char,std::char_traits< char > > &std_basic_string_Sl_char_Sg____rlshift__(std::basic_string< char > *self,std::basic_ostream< char,std::char_traits< char > > &out){
	out << *self;
	return out;
      }
SWIGINTERN bool std_basic_string_Sl_char_Sg__operator_Se__Se_(std::basic_string< char > *self,std::basic_string< char > const &v){
    return *self == v;
  }
SWIGINTERN bool std_basic_string_Sl_char_Sg__operator_SN__Se_(std::basic_string< char > *self,std::basic_string< char > const &v){
    return *self != v;
  }
SWIGINTERN bool std_basic_string_Sl_char_Sg__operator_Sg_(std::basic_string< char > *self,std::basic_string< char > const &v){
    return *self > v;
  }
SWIGINTERN bool std_basic_string_Sl_char_Sg__operator_Sl_(std::basic_string< char > *self,std::basic_string< char > const &v){
    return *self < v;
  }
SWIGINTERN bool std_basic_string_Sl_char_Sg__operator_Sg__Se_(std::basic_string< char > *self,std::basic_string< char > const &v){
    return *self >= v;
  }
SWIGINTERN bool std_basic_string_Sl_char_Sg__operator_Sl__Se_(std::basic_string< char > *self,std::basic_string< char > const &v){
    return *self <= v;
  }
SWIGINTERN int ListWrapper_Sl_SBMLNamespaces_Sg____len__(ListWrapper< SBMLNamespaces > *self){
    return self->getSize();
  }

SWIGINTERNINLINE PyObject*
  SWIG_From_int  (int value)
{
  return PyInt_FromLong((long) value);
}

SWIGINTERN int ListWrapper_Sl_CVTerm_Sg____len__(ListWrapper< CVTerm > *self){
    return self->getSize();
  }
SWIGINTERN int ListWrapper_Sl_Date_Sg____len__(ListWrapper< Date > *self){
    return self->getSize();
  }
SWIGINTERN int ListWrapper_Sl_ModelCreator_Sg____len__(ListWrapper< ModelCreator > *self){
    return self->getSize();
  }
SWIGINTERN int ListWrapper_Sl_SBase_Sg____len__(ListWrapper< SBase > *self){
    return self->getSize();
  }

SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< int >(v);
    }
  }  
  return res;
}


SWIGINTERN int
SWIG_AsVal_bool (PyObject *obj, bool *val)
{
  int r;
  if (!PyBool_Check(obj))
    return SWIG_ERROR;
  r = PyObject_IsTrue(obj);
  if (r == -1)
    return SWIG_ERROR;
  if (val) *val = r ? true : false;
  return SWIG_OK;
}

SWIGINTERN ListWrapper< SBase > SBase_getListOfAllElements__SWIG_0(SBase *self,ElementFilter *filter=NULL){
		List* list = self->getAllElements(filter);
		return ListWrapper<SBase>(list);
	}
SWIGINTERN ListWrapper< SBase > SBase_getListOfAllElementsFromPlugins__SWIG_0(SBase *self,ElementFilter *filter=NULL){
		List* list = self->getAllElementsFromPlugins(filter);
		return ListWrapper<SBase>(list);
	}
SWIGINTERN int ListOf___len__(ListOf *self){
    return self->size();
  }
SWIGINTERN void Model_renameIDs(Model *self,ListWrapper< SBase > &elements,IdentifierTransformer *idTransformer){
		List *list = elements.getList();
		self->renameIDs(list, idTransformer);
   }

SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_char  (unsigned char value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UCHAR_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned char >(v);
    }
  }  
  return res;
}


  #define SWIG_From_double   PyFloat_FromDouble 


/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
#ifndef SWIG_isfinite
/* isfinite() is a macro for C99 */
# if defined(isfinite)
#  define SWIG_isfinite(X) (isfinite(X))
# elif defined(__cplusplus) && __cplusplus >= 201103L
/* Use a template so that this works whether isfinite() is std::isfinite() or
 * in the global namespace.  The reality seems to vary between compiler
 * versions.
 *
 * Make sure namespace std exists to avoid compiler warnings.
 *
 * extern "C++" is required as this fragment can end up inside an extern "C" { } block
 */
namespace std { }
extern "C++" template<typename T>
inline int SWIG_isfinite_func(T x) {
  using namespace std;
  return isfinite(x);
}
#  define SWIG_isfinite(X) (SWIG_isfinite_func(X))
# elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#  define SWIG_isfinite(X) (__builtin_isfinite(X))
# elif defined(__clang__) && defined(__has_builtin)
#  if __has_builtin(__builtin_isfinite)
#   define SWIG_isfinite(X) (__builtin_isfinite(X))
#  endif
# elif defined(_MSC_VER)
#  define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)
#  include <ieeefp.h>
#  define SWIG_isfinite(X) (finite(X))
# endif
#endif


/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
#ifdef SWIG_isfinite
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
#else
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
#endif


SWIGINTERN int
SWIG_AsVal_float (PyObject * obj, float *val)
{
  double v;
  int res = SWIG_AsVal_double (obj, &v);
  if (SWIG_IsOK(res)) {
    if (SWIG_Float_Overflow_Check(v)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< float >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_From_float  (float value)
{    
  return SWIG_From_double  (value);
}

SWIGINTERN void XMLOutputStream_writeAttributeBool__SWIG_0(XMLOutputStream *self,std::string const &name,bool const &value){
    self->writeAttribute(name, value);
  }
SWIGINTERN void XMLOutputStream_writeAttributeBool__SWIG_1(XMLOutputStream *self,XMLTriple const &name,bool const &value){
    self->writeAttribute(name, value);
  }
SWIGINTERN void RDFAnnotationParser_parseRDFAnnotation__SWIG_3(XMLNode const *annotation,ListWrapper< CVTerm > *CVTerms){
    if (!CVTerms) return;

    List *list = CVTerms->getList();
    RDFAnnotationParser::parseRDFAnnotation(annotation,list);
  }
SWIGINTERN void RDFAnnotationParser_parseRDFAnnotation__SWIG_4(XMLNode const *annotation,ListWrapper< CVTerm > *CVTerms,char const *metaId=NULL,XMLInputStream *stream=NULL){
    if (!CVTerms) return;

    List *list = CVTerms->getList();
    RDFAnnotationParser::parseRDFAnnotation(annotation,list, metaId, stream);
  }
SWIGINTERN ListWrapper< SBase > SBasePlugin_getListOfAllElements__SWIG_0(SBasePlugin *self,ElementFilter *filter=NULL){
		List* list = self->getAllElements(filter);
		return ListWrapper<SBase>(list);
	}


#include <sbml/common/libsbml-config-common.h>


#include <sbml/math/ASTNodeType.h>
#include <sbml/math/ASTNode.h>
#include <sbml/math/MathML.h>
#include <sbml/math/L3FormulaFormatter.h>
#include <sbml/math/FormulaFormatter.h>
#include <sbml/math/FormulaParser.h>
#include <sbml/math/L3Parser.h>
#include <sbml/math/L3ParserSettings.h>
#include <sbml/math/DefinitionURLRegistry.h>
#include <sbml/util/MathFilter.h>



SWIGINTERN ListWrapper< ASTNode > ASTNode_getListOfNodes(ASTNode *self){
    List *list = self->getListOfNodes(ASTNode_true);
    return ListWrapper<ASTNode>(list);
  }


/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */

#include "libsbml_wrap.h"

SwigDirector_IdentifierTransformer::SwigDirector_IdentifierTransformer(PyObject *self): IdentifierTransformer(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((IdentifierTransformer *)this, this); 
}




SwigDirector_IdentifierTransformer::~SwigDirector_IdentifierTransformer() {
}

int SwigDirector_IdentifierTransformer::transform(SBase *element) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(element), SWIGTYPE_p_SBase,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call IdentifierTransformer.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "transform";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("transform");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'IdentifierTransformer.transform'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


SwigDirector_ElementFilter::SwigDirector_ElementFilter(PyObject *self): ElementFilter(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((ElementFilter *)this, this); 
}




SwigDirector_ElementFilter::~SwigDirector_ElementFilter() {
}

bool SwigDirector_ElementFilter::filter(SBase const *element) {
  bool c_result = SwigValueInit< bool >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(element), SWIGTYPE_p_SBase,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ElementFilter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "filter";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("filter");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'ElementFilter.filter'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


SwigDirector_SBMLConverter::SwigDirector_SBMLConverter(PyObject *self): SBMLConverter(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((SBMLConverter *)this, this); 
}




SwigDirector_SBMLConverter::SwigDirector_SBMLConverter(PyObject *self, std::string const &name): SBMLConverter(name), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((SBMLConverter *)this, this); 
}




SwigDirector_SBMLConverter::SwigDirector_SBMLConverter(PyObject *self, SBMLConverter const &orig): SBMLConverter(orig), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((SBMLConverter *)this, this); 
}




SwigDirector_SBMLConverter::~SwigDirector_SBMLConverter() {
}

SBMLConverter *SwigDirector_SBMLConverter::clone() const {
  SBMLConverter *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLConverter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "clone";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("clone");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLConverter.clone'");
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_SBMLConverter,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""SBMLConverter *""'");
  }
  c_result = reinterpret_cast< SBMLConverter * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (SBMLConverter *) c_result;
}


SBMLDocument *SwigDirector_SBMLConverter::getDocument() {
  SBMLDocument *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLConverter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "getDocument";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("getDocument");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLConverter.getDocument'");
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_SBMLDocument,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""SBMLDocument *""'");
  }
  c_result = reinterpret_cast< SBMLDocument * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (SBMLDocument *) c_result;
}


SBMLDocument const *SwigDirector_SBMLConverter::getDocument() const {
  SBMLDocument *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLConverter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "getDocument";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("getDocument");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLConverter.getDocument'");
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_SBMLDocument,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""SBMLDocument const *""'");
  }
  c_result = reinterpret_cast< SBMLDocument * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (SBMLDocument const *) c_result;
}


ConversionProperties SwigDirector_SBMLConverter::getDefaultProperties() const {
  void *swig_argp ;
  int swig_res = 0 ;
  
  ConversionProperties c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLConverter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "getDefaultProperties";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("getDefaultProperties");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLConverter.getDefaultProperties'");
    }
  }
  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ConversionProperties""'");
  }
  c_result = *(reinterpret_cast< ConversionProperties * >(swig_argp));
  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< ConversionProperties * >(swig_argp);
  return (ConversionProperties) c_result;
}


SBMLNamespaces *SwigDirector_SBMLConverter::getTargetNamespaces() {
  SBMLNamespaces *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLConverter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "getTargetNamespaces";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("getTargetNamespaces");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLConverter.getTargetNamespaces'");
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_SBMLNamespaces,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""SBMLNamespaces *""'");
  }
  c_result = reinterpret_cast< SBMLNamespaces * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (SBMLNamespaces *) c_result;
}


bool SwigDirector_SBMLConverter::matchesProperties(ConversionProperties const &props) const {
  bool c_result = SwigValueInit< bool >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&props), SWIGTYPE_p_ConversionProperties,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLConverter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "matchesProperties";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("matchesProperties");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLConverter.matchesProperties'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


int SwigDirector_SBMLConverter::setDocument(SBMLDocument const *doc) {
  return SBMLConverter::setDocument(doc);
}


int SwigDirector_SBMLConverter::setDocument(SBMLDocument *doc) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(doc), SWIGTYPE_p_SBMLDocument,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLConverter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char *const swig_method_name = "setDocument";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("setDocument");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLConverter.setDocument'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_SBMLConverter::setProperties(ConversionProperties const *props) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(props), SWIGTYPE_p_ConversionProperties,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLConverter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char *const swig_method_name = "setProperties";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("setProperties");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLConverter.setProperties'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


ConversionProperties *SwigDirector_SBMLConverter::getProperties() const {
  ConversionProperties *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLConverter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char *const swig_method_name = "getProperties";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("getProperties");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLConverter.getProperties'");
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_ConversionProperties,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ConversionProperties *""'");
  }
  c_result = reinterpret_cast< ConversionProperties * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (ConversionProperties *) c_result;
}


int SwigDirector_SBMLConverter::convert() {
  int c_result = SwigValueInit< int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLConverter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char *const swig_method_name = "convert";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("convert");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLConverter.convert'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


SwigDirector_SBMLValidator::SwigDirector_SBMLValidator(PyObject *self): SBMLValidator(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((SBMLValidator *)this, this); 
}




SwigDirector_SBMLValidator::SwigDirector_SBMLValidator(PyObject *self, SBMLValidator const &orig): SBMLValidator(orig), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((SBMLValidator *)this, this); 
}




SwigDirector_SBMLValidator::~SwigDirector_SBMLValidator() {
}

SBMLValidator *SwigDirector_SBMLValidator::clone() const {
  SBMLValidator *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLValidator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "clone";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("clone");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLValidator.clone'");
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_SBMLValidator,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""SBMLValidator *""'");
  }
  c_result = reinterpret_cast< SBMLValidator * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (SBMLValidator *) c_result;
}


SBMLDocument *SwigDirector_SBMLValidator::getDocument() {
  SBMLDocument *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLValidator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char *const swig_method_name = "getDocument";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("getDocument");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLValidator.getDocument'");
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_SBMLDocument,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""SBMLDocument *""'");
  }
  c_result = reinterpret_cast< SBMLDocument * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (SBMLDocument *) c_result;
}


SBMLDocument const *SwigDirector_SBMLValidator::getDocument() const {
  SBMLDocument *c_result = 0 ;
  void *swig_argp ;
  int swig_res ;
  swig_owntype own ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLValidator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char *const swig_method_name = "getDocument";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("getDocument");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLValidator.getDocument'");
    }
  }
  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_SBMLDocument,  0  | SWIG_POINTER_DISOWN, &own);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""SBMLDocument const *""'");
  }
  c_result = reinterpret_cast< SBMLDocument * >(swig_argp);
  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
  return (SBMLDocument const *) c_result;
}


int SwigDirector_SBMLValidator::setDocument(SBMLDocument const *doc) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(doc), SWIGTYPE_p_SBMLDocument,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLValidator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char *const swig_method_name = "setDocument";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("setDocument");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLValidator.setDocument'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


unsigned int SwigDirector_SBMLValidator::validate() {
  unsigned int c_result = SwigValueInit< unsigned int >() ;
  
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLValidator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char *const swig_method_name = "validate";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("validate");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLValidator.validate'");
    }
  }
  unsigned int swig_val;
  int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""unsigned int""'");
  }
  c_result = static_cast< unsigned int >(swig_val);
  return (unsigned int) c_result;
}


void SwigDirector_SBMLValidator::clearFailures() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SBMLValidator.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char *const swig_method_name = "clearFailures";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject args = PyTuple_New(0);
  swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("clearFailures");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SBMLValidator.clearFailures'");
    }
  }
}


SwigDirector_Callback::SwigDirector_Callback(PyObject *self): Callback(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Callback *)this, this); 
}




SwigDirector_Callback::~SwigDirector_Callback() {
}

int SwigDirector_Callback::process(SBMLDocument *doc) {
  int c_result = SwigValueInit< int >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(doc), SWIGTYPE_p_SBMLDocument,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Callback.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "process";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("process");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'Callback.process'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


SwigDirector_MathFilter::SwigDirector_MathFilter(PyObject *self): MathFilter(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((MathFilter *)this, this); 
}




SwigDirector_MathFilter::~SwigDirector_MathFilter() {
}

bool SwigDirector_MathFilter::filter(SBase const *element) {
  bool c_result = SwigValueInit< bool >() ;
  
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(element), SWIGTYPE_p_SBase,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MathFilter.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char *const swig_method_name = "filter";
  PyObject *method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
  swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("filter");
  swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MathFilter.filter'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_new_ModelCreatorList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ModelCreatorList", 0, 0, 0)) SWIG_fail;
  result = (ListWrapper< ModelCreator > *)new ListWrapper< ModelCreator >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListWrapperT_ModelCreator_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ModelCreatorList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModelCreatorList" "', argument " "1"" of type '" "ListWrapper< ModelCreator > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreatorList_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  ModelCreator *arg2 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelCreatorList_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreatorList_add" "', argument " "1"" of type '" "ListWrapper< ModelCreator > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCreatorList_add" "', argument " "2"" of type '" "ModelCreator *""'"); 
  }
  arg2 = reinterpret_cast< ModelCreator * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreatorList_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ModelCreator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelCreatorList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreatorList_get" "', argument " "1"" of type '" "ListWrapper< ModelCreator > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModelCreatorList_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ModelCreator *)((ListWrapper< ModelCreator > const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelCreator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreatorList_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  ModelCreator *arg2 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelCreatorList_prepend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreatorList_prepend" "', argument " "1"" of type '" "ListWrapper< ModelCreator > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCreatorList_prepend" "', argument " "2"" of type '" "ModelCreator *""'"); 
  }
  arg2 = reinterpret_cast< ModelCreator * >(argp2);
  (arg1)->prepend(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreatorList_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ModelCreator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelCreatorList_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreatorList_remove" "', argument " "1"" of type '" "ListWrapper< ModelCreator > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModelCreatorList_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ModelCreator *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelCreator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreatorList_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreatorList_getSize" "', argument " "1"" of type '" "ListWrapper< ModelCreator > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  result = (unsigned int)((ListWrapper< ModelCreator > const *)arg1)->getSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ModelCreatorList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListWrapperT_ModelCreator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ModelCreatorList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DateList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DateList", 0, 0, 0)) SWIG_fail;
  result = (ListWrapper< Date > *)new ListWrapper< Date >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListWrapperT_Date_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DateList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateList" "', argument " "1"" of type '" "ListWrapper< Date > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateList_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  Date *arg2 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DateList_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateList_add" "', argument " "1"" of type '" "ListWrapper< Date > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateList_add" "', argument " "2"" of type '" "Date *""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateList_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Date *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DateList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateList_get" "', argument " "1"" of type '" "ListWrapper< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateList_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Date *)((ListWrapper< Date > const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateList_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  Date *arg2 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DateList_prepend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateList_prepend" "', argument " "1"" of type '" "ListWrapper< Date > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateList_prepend" "', argument " "2"" of type '" "Date *""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  (arg1)->prepend(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateList_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Date *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DateList_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateList_remove" "', argument " "1"" of type '" "ListWrapper< Date > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateList_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Date *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateList_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateList_getSize" "', argument " "1"" of type '" "ListWrapper< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  result = (unsigned int)((ListWrapper< Date > const *)arg1)->getSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DateList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListWrapperT_Date_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DateList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CVTermList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CVTermList", 0, 0, 0)) SWIG_fail;
  result = (ListWrapper< CVTerm > *)new ListWrapper< CVTerm >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListWrapperT_CVTerm_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CVTermList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CVTermList" "', argument " "1"" of type '" "ListWrapper< CVTerm > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTermList_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  CVTerm *arg2 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CVTermList_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTermList_add" "', argument " "1"" of type '" "ListWrapper< CVTerm > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CVTermList_add" "', argument " "2"" of type '" "CVTerm *""'"); 
  }
  arg2 = reinterpret_cast< CVTerm * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTermList_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  CVTerm *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CVTermList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTermList_get" "', argument " "1"" of type '" "ListWrapper< CVTerm > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CVTermList_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CVTerm *)((ListWrapper< CVTerm > const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTermList_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  CVTerm *arg2 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CVTermList_prepend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTermList_prepend" "', argument " "1"" of type '" "ListWrapper< CVTerm > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CVTermList_prepend" "', argument " "2"" of type '" "CVTerm *""'"); 
  }
  arg2 = reinterpret_cast< CVTerm * >(argp2);
  (arg1)->prepend(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTermList_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  CVTerm *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CVTermList_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTermList_remove" "', argument " "1"" of type '" "ListWrapper< CVTerm > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CVTermList_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CVTerm *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTermList_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTermList_getSize" "', argument " "1"" of type '" "ListWrapper< CVTerm > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  result = (unsigned int)((ListWrapper< CVTerm > const *)arg1)->getSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CVTermList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListWrapperT_CVTerm_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CVTermList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ASTNodeList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ASTNode > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ASTNodeList", 0, 0, 0)) SWIG_fail;
  result = (ListWrapper< ASTNode > *)new ListWrapper< ASTNode >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListWrapperT_ASTNode_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ASTNodeList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ASTNode > *arg1 = (ListWrapper< ASTNode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ASTNode_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ASTNodeList" "', argument " "1"" of type '" "ListWrapper< ASTNode > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ASTNode > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeList_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ASTNode > *arg1 = (ListWrapper< ASTNode > *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNodeList_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ASTNode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeList_add" "', argument " "1"" of type '" "ListWrapper< ASTNode > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ASTNode > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNodeList_add" "', argument " "2"" of type '" "ASTNode *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeList_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ASTNode > *arg1 = (ListWrapper< ASTNode > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ASTNode *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNodeList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ASTNode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeList_get" "', argument " "1"" of type '" "ListWrapper< ASTNode > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ASTNode > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNodeList_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ASTNode *)((ListWrapper< ASTNode > const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeList_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ASTNode > *arg1 = (ListWrapper< ASTNode > *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNodeList_prepend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ASTNode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeList_prepend" "', argument " "1"" of type '" "ListWrapper< ASTNode > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ASTNode > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNodeList_prepend" "', argument " "2"" of type '" "ASTNode *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  (arg1)->prepend(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeList_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ASTNode > *arg1 = (ListWrapper< ASTNode > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ASTNode *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNodeList_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ASTNode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeList_remove" "', argument " "1"" of type '" "ListWrapper< ASTNode > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ASTNode > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNodeList_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ASTNode *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeList_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ASTNode > *arg1 = (ListWrapper< ASTNode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ASTNode_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeList_getSize" "', argument " "1"" of type '" "ListWrapper< ASTNode > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ASTNode > * >(argp1);
  result = (unsigned int)((ListWrapper< ASTNode > const *)arg1)->getSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ASTNodeList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListWrapperT_ASTNode_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ASTNodeList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBMLNamespacesList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SBMLNamespacesList", 0, 0, 0)) SWIG_fail;
  result = (ListWrapper< SBMLNamespaces > *)new ListWrapper< SBMLNamespaces >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLNamespacesList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLNamespacesList" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespacesList_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespacesList_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespacesList_add" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLNamespacesList_add" "', argument " "2"" of type '" "SBMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespacesList_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBMLNamespaces *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespacesList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespacesList_get" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLNamespacesList_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBMLNamespaces *)((ListWrapper< SBMLNamespaces > const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespacesList_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespacesList_prepend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespacesList_prepend" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLNamespacesList_prepend" "', argument " "2"" of type '" "SBMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces * >(argp2);
  (arg1)->prepend(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespacesList_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBMLNamespaces *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespacesList_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespacesList_remove" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLNamespacesList_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBMLNamespaces *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespacesList_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespacesList_getSize" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  result = (unsigned int)((ListWrapper< SBMLNamespaces > const *)arg1)->getSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLNamespacesList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLNamespacesList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBaseList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SBaseList", 0, 0, 0)) SWIG_fail;
  result = (ListWrapper< SBase > *)new ListWrapper< SBase >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListWrapperT_SBase_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBaseList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBaseList" "', argument " "1"" of type '" "ListWrapper< SBase > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBaseList_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBaseList_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBaseList_add" "', argument " "1"" of type '" "ListWrapper< SBase > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBaseList_add" "', argument " "2"" of type '" "SBase *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBaseList_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBaseList_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBaseList_get" "', argument " "1"" of type '" "ListWrapper< SBase > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBaseList_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBase *)((ListWrapper< SBase > const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBase, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBaseList_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBaseList_prepend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBaseList_prepend" "', argument " "1"" of type '" "ListWrapper< SBase > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBaseList_prepend" "', argument " "2"" of type '" "SBase *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  (arg1)->prepend(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBaseList_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBaseList_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBaseList_remove" "', argument " "1"" of type '" "ListWrapper< SBase > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBaseList_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBase *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBase, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBaseList_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBaseList_getSize" "', argument " "1"" of type '" "ListWrapper< SBase > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  result = (unsigned int)((ListWrapper< SBase > const *)arg1)->getSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBaseList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListWrapperT_SBase_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBaseList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  try {
    result = (swig::SwigPyIterator *)(arg1)->incr(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (swig::SwigPyIterator *)(arg1)->incr();
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_incr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SwigPyIterator_incr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator_incr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    swig::SwigPyIterator::incr(size_t)\n"
    "    swig::SwigPyIterator::incr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  try {
    result = (swig::SwigPyIterator *)(arg1)->decr(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (swig::SwigPyIterator *)(arg1)->decr();
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    swig::SwigPyIterator::decr(size_t)\n"
    "    swig::SwigPyIterator::decr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ptrdiff_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  try {
    result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
  } catch(std::invalid_argument &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
  }
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  try {
    result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
  } catch(std::invalid_argument &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (PyObject *)(arg1)->next();
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (PyObject *)(arg1)->__next__();
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (PyObject *)(arg1)->previous();
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ptrdiff_t result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN int Swig_var_string_npos_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable string_npos is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_string_npos_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_size_t(static_cast< size_t >(std::basic_string< char >::npos));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_string__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_string" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_string" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  result = (std::basic_string< char > *)new std::basic_string< char >((char const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::basic_string< char >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_length" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  result = ((std::basic_string< char > const *)arg1)->length();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_max_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::basic_string< char >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_max_size" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  result = ((std::basic_string< char > const *)arg1)->max_size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_assign__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_assign" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_assign" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_assign" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (std::basic_string< char > *) &(arg1)->assign((std::basic_string< char > const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_assign__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  std::basic_string< char >::size_type arg3 ;
  std::basic_string< char >::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_assign" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_assign" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_assign" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_assign" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_assign" "', argument " "4"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::size_type >(val4);
  result = (std::basic_string< char > *) &(arg1)->assign((std::basic_string< char > const &)*arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_assign__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char *arg2 = (char *) 0 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_assign" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_assign" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_assign" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = (std::basic_string< char > *) &(arg1)->assign((char const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  std::basic_string< char > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_insert" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_insert" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "string_insert" "', argument " "3"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_insert" "', argument " "3"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg3 = ptr;
  }
  result = (std::basic_string< char > *) &(arg1)->insert(arg2,(std::basic_string< char > const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  std::basic_string< char > *arg3 = 0 ;
  std::basic_string< char >::size_type arg4 ;
  std::basic_string< char >::size_type arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_insert" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_insert" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "string_insert" "', argument " "3"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_insert" "', argument " "3"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_insert" "', argument " "4"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::size_type >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "string_insert" "', argument " "5"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg5 = static_cast< std::basic_string< char >::size_type >(val5);
  result = (std::basic_string< char > *) &(arg1)->insert(arg2,(std::basic_string< char > const &)*arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_insert__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  char *arg3 = (char *) 0 ;
  std::basic_string< char >::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_insert" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_insert" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "string_insert" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_insert" "', argument " "4"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::size_type >(val4);
  result = (std::basic_string< char > *) &(arg1)->insert(arg2,(char const *)arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_insert__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  std::basic_string< char >::size_type arg3 ;
  char arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_insert" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_insert" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_insert" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  ecode4 = SWIG_AsVal_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_insert" "', argument " "4"" of type '" "char""'");
  } 
  arg4 = static_cast< char >(val4);
  result = (std::basic_string< char > *) &(arg1)->insert(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_erase" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_erase" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_erase" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = (std::basic_string< char > *) &(arg1)->erase(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_erase" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_erase" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  result = (std::basic_string< char > *) &(arg1)->erase(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_erase" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  result = (std::basic_string< char > *) &(arg1)->erase();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_replace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  std::basic_string< char >::size_type arg3 ;
  std::basic_string< char > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_replace" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res4 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "string_replace" "', argument " "4"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_replace" "', argument " "4"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg4 = ptr;
  }
  result = (std::basic_string< char > *) &(arg1)->replace(arg2,arg3,(std::basic_string< char > const &)*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_replace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  std::basic_string< char >::size_type arg3 ;
  std::basic_string< char > *arg4 = 0 ;
  std::basic_string< char >::size_type arg5 ;
  std::basic_string< char >::size_type arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_replace" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res4 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "string_replace" "', argument " "4"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_replace" "', argument " "4"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "string_replace" "', argument " "5"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg5 = static_cast< std::basic_string< char >::size_type >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "string_replace" "', argument " "6"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg6 = static_cast< std::basic_string< char >::size_type >(val6);
  result = (std::basic_string< char > *) &(arg1)->replace(arg2,arg3,(std::basic_string< char > const &)*arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_replace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  std::basic_string< char >::size_type arg3 ;
  char *arg4 = (char *) 0 ;
  std::basic_string< char >::size_type arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_replace" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "string_replace" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "string_replace" "', argument " "5"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg5 = static_cast< std::basic_string< char >::size_type >(val5);
  result = (std::basic_string< char > *) &(arg1)->replace(arg2,arg3,(char const *)arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_replace__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  std::basic_string< char >::size_type arg3 ;
  std::basic_string< char >::size_type arg4 ;
  char arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_replace" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_replace" "', argument " "4"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::size_type >(val4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "string_replace" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  result = (std::basic_string< char > *) &(arg1)->replace(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_copy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char *arg2 = (char *) 0 ;
  std::basic_string< char >::size_type arg3 ;
  std::basic_string< char >::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_copy" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_copy" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_copy" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_copy" "', argument " "4"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::size_type >(val4);
  result = ((std::basic_string< char > const *)arg1)->copy(arg2,arg3,arg4);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_copy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char *arg2 = (char *) 0 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_copy" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_copy" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_copy" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->copy(arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_copy", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_copy__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_string_copy__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::copy(char *,std::basic_string< char >::size_type,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::copy(char *,std::basic_string< char >::size_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string_c_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_c_str" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  result = (char *)((std::basic_string< char > const *)arg1)->c_str();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char *arg2 = (char *) 0 ;
  std::basic_string< char >::size_type arg3 ;
  std::basic_string< char >::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_find" "', argument " "4"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::size_type >(val4);
  result = ((std::basic_string< char > const *)arg1)->find((char const *)arg2,arg3,arg4);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_find" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->find((std::basic_string< char > const &)*arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_find" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::basic_string< char > const *)arg1)->find((std::basic_string< char > const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char arg2 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_find" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->find(arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_find" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  result = ((std::basic_string< char > const *)arg1)->find(arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_find", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_string_find__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_string_find__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_find__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_find__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_string_find__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_find'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::find(char const *,std::basic_string< char >::size_type,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find(std::basic_string< char > const &,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find(std::basic_string< char > const &) const\n"
    "    std::basic_string< char >::find(char,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find(char) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string_rfind__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_rfind" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_rfind" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_rfind" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_rfind" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->rfind((std::basic_string< char > const &)*arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_rfind__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_rfind" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_rfind" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_rfind" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::basic_string< char > const *)arg1)->rfind((std::basic_string< char > const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_rfind__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char *arg2 = (char *) 0 ;
  std::basic_string< char >::size_type arg3 ;
  std::basic_string< char >::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_rfind" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_rfind" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_rfind" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_rfind" "', argument " "4"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::size_type >(val4);
  result = ((std::basic_string< char > const *)arg1)->rfind((char const *)arg2,arg3,arg4);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_rfind__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char arg2 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_rfind" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_rfind" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_rfind" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->rfind(arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_rfind__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_rfind" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_rfind" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  result = ((std::basic_string< char > const *)arg1)->rfind(arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_rfind(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_rfind", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_string_rfind__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_string_rfind__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_rfind__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_rfind__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_string_rfind__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_rfind'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::rfind(std::basic_string< char > const &,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::rfind(std::basic_string< char > const &) const\n"
    "    std::basic_string< char >::rfind(char const *,std::basic_string< char >::size_type,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::rfind(char,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::rfind(char) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string_find_first_of__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_first_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find_first_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_find_first_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find_first_of" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->find_first_of((std::basic_string< char > const &)*arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_first_of__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_first_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find_first_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_find_first_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::basic_string< char > const *)arg1)->find_first_of((std::basic_string< char > const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_first_of__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char *arg2 = (char *) 0 ;
  std::basic_string< char >::size_type arg3 ;
  std::basic_string< char >::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_first_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find_first_of" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find_first_of" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_find_first_of" "', argument " "4"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::size_type >(val4);
  result = ((std::basic_string< char > const *)arg1)->find_first_of((char const *)arg2,arg3,arg4);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_first_of__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char arg2 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_first_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_find_first_of" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find_first_of" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->find_first_of(arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_first_of__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_first_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_find_first_of" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  result = ((std::basic_string< char > const *)arg1)->find_first_of(arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_first_of(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_find_first_of", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_string_find_first_of__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_string_find_first_of__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_find_first_of__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_find_first_of__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_string_find_first_of__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_find_first_of'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::find_first_of(std::basic_string< char > const &,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find_first_of(std::basic_string< char > const &) const\n"
    "    std::basic_string< char >::find_first_of(char const *,std::basic_string< char >::size_type,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find_first_of(char,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find_first_of(char) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string_find_last_of__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_last_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find_last_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_find_last_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find_last_of" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->find_last_of((std::basic_string< char > const &)*arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_last_of__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_last_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find_last_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_find_last_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::basic_string< char > const *)arg1)->find_last_of((std::basic_string< char > const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_last_of__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char *arg2 = (char *) 0 ;
  std::basic_string< char >::size_type arg3 ;
  std::basic_string< char >::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_last_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find_last_of" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find_last_of" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_find_last_of" "', argument " "4"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::size_type >(val4);
  result = ((std::basic_string< char > const *)arg1)->find_last_of((char const *)arg2,arg3,arg4);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_last_of__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char arg2 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_last_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_find_last_of" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find_last_of" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->find_last_of(arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_last_of__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_last_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_find_last_of" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  result = ((std::basic_string< char > const *)arg1)->find_last_of(arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_last_of(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_find_last_of", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_string_find_last_of__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_string_find_last_of__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_find_last_of__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_find_last_of__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_string_find_last_of__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_find_last_of'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::find_last_of(std::basic_string< char > const &,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find_last_of(std::basic_string< char > const &) const\n"
    "    std::basic_string< char >::find_last_of(char const *,std::basic_string< char >::size_type,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find_last_of(char,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find_last_of(char) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string_find_first_not_of__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_first_not_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find_first_not_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_find_first_not_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find_first_not_of" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->find_first_not_of((std::basic_string< char > const &)*arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_first_not_of__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_first_not_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find_first_not_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_find_first_not_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::basic_string< char > const *)arg1)->find_first_not_of((std::basic_string< char > const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_first_not_of__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char *arg2 = (char *) 0 ;
  std::basic_string< char >::size_type arg3 ;
  std::basic_string< char >::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_first_not_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find_first_not_of" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find_first_not_of" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_find_first_not_of" "', argument " "4"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::size_type >(val4);
  result = ((std::basic_string< char > const *)arg1)->find_first_not_of((char const *)arg2,arg3,arg4);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_first_not_of__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char arg2 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_first_not_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_find_first_not_of" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find_first_not_of" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->find_first_not_of(arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_first_not_of__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_first_not_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_find_first_not_of" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  result = ((std::basic_string< char > const *)arg1)->find_first_not_of(arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_first_not_of(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_find_first_not_of", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_string_find_first_not_of__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_string_find_first_not_of__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_find_first_not_of__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_find_first_not_of__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_string_find_first_not_of__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_find_first_not_of'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::find_first_not_of(std::basic_string< char > const &,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find_first_not_of(std::basic_string< char > const &) const\n"
    "    std::basic_string< char >::find_first_not_of(char const *,std::basic_string< char >::size_type,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find_first_not_of(char,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find_first_not_of(char) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string_find_last_not_of__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_last_not_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find_last_not_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_find_last_not_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find_last_not_of" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->find_last_not_of((std::basic_string< char > const &)*arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_last_not_of__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_last_not_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find_last_not_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_find_last_not_of" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::basic_string< char > const *)arg1)->find_last_not_of((std::basic_string< char > const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_last_not_of__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char *arg2 = (char *) 0 ;
  std::basic_string< char >::size_type arg3 ;
  std::basic_string< char >::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_last_not_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_find_last_not_of" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find_last_not_of" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_find_last_not_of" "', argument " "4"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::size_type >(val4);
  result = ((std::basic_string< char > const *)arg1)->find_last_not_of((char const *)arg2,arg3,arg4);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_last_not_of__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char arg2 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_last_not_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_find_last_not_of" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_find_last_not_of" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->find_last_not_of(arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_last_not_of__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  std::basic_string< char >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find_last_not_of" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_find_last_not_of" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  result = ((std::basic_string< char > const *)arg1)->find_last_not_of(arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_find_last_not_of(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_find_last_not_of", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_string_find_last_not_of__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_string_find_last_not_of__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_find_last_not_of__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_find_last_not_of__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_string_find_last_not_of__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_find_last_not_of'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::find_last_not_of(std::basic_string< char > const &,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find_last_not_of(std::basic_string< char > const &) const\n"
    "    std::basic_string< char >::find_last_not_of(char const *,std::basic_string< char >::size_type,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find_last_not_of(char,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::find_last_not_of(char) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string_substr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  std::basic_string< char >::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::basic_string< char > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_substr" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_substr" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_substr" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  result = ((std::basic_string< char > const *)arg1)->substr(arg2,arg3);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_substr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::basic_string< char > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_substr" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_substr" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  result = ((std::basic_string< char > const *)arg1)->substr(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_substr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::basic_string< char > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_substr" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  result = ((std::basic_string< char > const *)arg1)->substr();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_substr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_substr", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_string_substr__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_string_substr__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_substr__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_substr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::substr(std::basic_string< char >::size_type,std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::substr(std::basic_string< char >::size_type) const\n"
    "    std::basic_string< char >::substr() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_string__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (std::basic_string< char > *)new std::basic_string< char >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_string__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_string" "', argument " "1"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_string" "', argument " "1"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::basic_string< char > *)new std::basic_string< char >((std::basic_string< char > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_empty" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  result = (bool)((std::basic_string< char > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::basic_string< char >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_size" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  result = ((std::basic_string< char > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "string_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_swap" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_swap" "', argument " "2"" of type '" "std::basic_string< char > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_swap" "', argument " "2"" of type '" "std::basic_string< char > &""'"); 
  }
  arg2 = reinterpret_cast< std::basic_string< char > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_resize" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_resize" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_erase__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::basic_string< char >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_erase" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_erase" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_erase" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
    } else {
      std::basic_string< char >::iterator * temp = reinterpret_cast< std::basic_string< char >::iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = std_basic_string_Sl_char_Sg__erase__SWIG_3(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new std::basic_string< char >::iterator(static_cast< const std::basic_string< char >::iterator& >(result))), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_erase__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::iterator arg2 ;
  std::basic_string< char >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::basic_string< char >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_erase" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_erase" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_erase" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
    } else {
      std::basic_string< char >::iterator * temp = reinterpret_cast< std::basic_string< char >::iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "string_erase" "', argument " "3"" of type '" "std::basic_string< char >::iterator""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_erase" "', argument " "3"" of type '" "std::basic_string< char >::iterator""'");
    } else {
      std::basic_string< char >::iterator * temp = reinterpret_cast< std::basic_string< char >::iterator * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = std_basic_string_Sl_char_Sg__erase__SWIG_4(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj((new std::basic_string< char >::iterator(static_cast< const std::basic_string< char >::iterator& >(result))), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_string_erase__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_string_erase__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_string_erase__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_string_erase__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_erase__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::erase(std::basic_string< char >::size_type,std::basic_string< char >::size_type)\n"
    "    std::basic_string< char >::erase(std::basic_string< char >::size_type)\n"
    "    std::basic_string< char >::erase()\n"
    "    std::basic_string< char >::erase(std::basic_string< char >::iterator)\n"
    "    std::basic_string< char >::erase(std::basic_string< char >::iterator,std::basic_string< char >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_string__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char >::size_type arg1 ;
  std::basic_string< char >::value_type arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_string" "', argument " "1"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg1 = static_cast< std::basic_string< char >::size_type >(val1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_string" "', argument " "2"" of type '" "std::basic_string< char >::value_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::value_type >(val2);
  result = (std::basic_string< char > *)new std::basic_string< char >(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_string(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_string", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_string__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_string__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_string__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_string__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_string'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::basic_string(char const *,std::basic_string< char >::size_type)\n"
    "    std::basic_string< char >::basic_string()\n"
    "    std::basic_string< char >::basic_string(std::basic_string< char > const &)\n"
    "    std::basic_string< char >::basic_string(std::basic_string< char >::size_type,std::basic_string< char >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string_assign__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  std::basic_string< char >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_assign" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_assign" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_assign" "', argument " "3"" of type '" "std::basic_string< char >::value_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::value_type >(val3);
  (arg1)->assign(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_assign(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_assign", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_string_assign__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_assign__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_assign__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_string_assign__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_assign'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::assign(std::basic_string< char > const &)\n"
    "    std::basic_string< char >::assign(std::basic_string< char > const &,std::basic_string< char >::size_type,std::basic_string< char >::size_type)\n"
    "    std::basic_string< char >::assign(char const *,std::basic_string< char >::size_type)\n"
    "    std::basic_string< char >::assign(std::basic_string< char >::size_type,std::basic_string< char >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::size_type arg2 ;
  std::basic_string< char >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_resize" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_resize" "', argument " "2"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::size_type >(val2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_resize" "', argument " "3"" of type '" "std::basic_string< char >::value_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::value_type >(val3);
  (arg1)->resize(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_string_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::resize(std::basic_string< char >::size_type)\n"
    "    std::basic_string< char >::resize(std::basic_string< char >::size_type,std::basic_string< char >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string_insert__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::iterator arg2 ;
  std::basic_string< char >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  std::basic_string< char >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_insert" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_insert" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_insert" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
    } else {
      std::basic_string< char >::iterator * temp = reinterpret_cast< std::basic_string< char >::iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_insert" "', argument " "3"" of type '" "std::basic_string< char >::value_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::value_type >(val3);
  result = std_basic_string_Sl_char_Sg__insert__SWIG_4(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj((new std::basic_string< char >::iterator(static_cast< const std::basic_string< char >::iterator& >(result))), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_insert__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::iterator arg2 ;
  std::basic_string< char >::size_type arg3 ;
  std::basic_string< char >::value_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_insert" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_insert" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_insert" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
    } else {
      std::basic_string< char >::iterator * temp = reinterpret_cast< std::basic_string< char >::iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_insert" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  ecode4 = SWIG_AsVal_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_insert" "', argument " "4"" of type '" "std::basic_string< char >::value_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::value_type >(val4);
  std_basic_string_Sl_char_Sg__insert__SWIG_5(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_iterator" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  result = (swig::SwigPyIterator *)std_basic_string_Sl_char_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___nonzero__" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  result = (bool)std_basic_string_Sl_char_Sg____nonzero__((std::basic_string< char > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___bool__" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  result = (bool)std_basic_string_Sl_char_Sg____bool__((std::basic_string< char > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::basic_string< char >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___len__" "', argument " "1"" of type '" "std::basic_string< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  result = std_basic_string_Sl_char_Sg____len__((std::basic_string< char > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::difference_type arg2 ;
  std::basic_string< char >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::basic_string< char,std::char_traits< char >,std::allocator< char > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "string___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___getslice__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string___getslice__" "', argument " "2"" of type '" "std::basic_string< char >::difference_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string___getslice__" "', argument " "3"" of type '" "std::basic_string< char >::difference_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::difference_type >(val3);
  try {
    result = (std::basic_string< char,std::char_traits< char >,std::allocator< char > > *)std_basic_string_Sl_char_Sg____getslice__(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  } catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::difference_type arg2 ;
  std::basic_string< char >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___setslice__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string___setslice__" "', argument " "2"" of type '" "std::basic_string< char >::difference_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string___setslice__" "', argument " "3"" of type '" "std::basic_string< char >::difference_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::difference_type >(val3);
  try {
    std_basic_string_Sl_char_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  } catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::difference_type arg2 ;
  std::basic_string< char >::difference_type arg3 ;
  std::basic_string< char,std::char_traits< char >,std::allocator< char > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___setslice__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string___setslice__" "', argument " "2"" of type '" "std::basic_string< char >::difference_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string___setslice__" "', argument " "3"" of type '" "std::basic_string< char >::difference_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::difference_type >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res4 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "string___setslice__" "', argument " "4"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string___setslice__" "', argument " "4"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_basic_string_Sl_char_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg4);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  } catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_string___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::__setslice__(std::basic_string< char >::difference_type,std::basic_string< char >::difference_type)\n"
    "    std::basic_string< char >::__setslice__(std::basic_string< char >::difference_type,std::basic_string< char >::difference_type,std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::difference_type arg2 ;
  std::basic_string< char >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "string___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___delslice__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string___delslice__" "', argument " "2"" of type '" "std::basic_string< char >::difference_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string___delslice__" "', argument " "3"" of type '" "std::basic_string< char >::difference_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::difference_type >(val3);
  try {
    std_basic_string_Sl_char_Sg____delslice__(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  } catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___delitem__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string___delitem__" "', argument " "2"" of type '" "std::basic_string< char >::difference_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::difference_type >(val2);
  try {
    std_basic_string_Sl_char_Sg____delitem____SWIG_0(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  } catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::basic_string< char,std::char_traits< char >,std::allocator< char > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___getitem__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  try {
    result = (std::basic_string< char,std::char_traits< char >,std::allocator< char > > *)std_basic_string_Sl_char_Sg____getitem____SWIG_0(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  } catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::basic_string< char,std::char_traits< char >,std::allocator< char > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___setitem__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "string___setitem__" "', argument " "3"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string___setitem__" "', argument " "3"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_basic_string_Sl_char_Sg____setitem____SWIG_0(arg1,arg2,(std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  } catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___setitem__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  try {
    std_basic_string_Sl_char_Sg____setitem____SWIG_1(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  } catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___delitem__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  try {
    std_basic_string_Sl_char_Sg____delitem____SWIG_1(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  } catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_string___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_string___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::__delitem__(std::basic_string< char >::difference_type)\n"
    "    std::basic_string< char >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::basic_string< char >::value_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___getitem__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string___getitem__" "', argument " "2"" of type '" "std::basic_string< char >::difference_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::difference_type >(val2);
  try {
    result = (std::basic_string< char >::value_type)std_basic_string_Sl_char_Sg____getitem____SWIG_1(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_string___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_string___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::__getitem__(PySliceObject *)\n"
    "    std::basic_string< char >::__getitem__(std::basic_string< char >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::difference_type arg2 ;
  std::basic_string< char >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___setitem__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string___setitem__" "', argument " "2"" of type '" "std::basic_string< char >::difference_type""'");
  } 
  arg2 = static_cast< std::basic_string< char >::difference_type >(val2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string___setitem__" "', argument " "3"" of type '" "std::basic_string< char >::value_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::value_type >(val3);
  try {
    std_basic_string_Sl_char_Sg____setitem____SWIG_2(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_string___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_string___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::__setitem__(PySliceObject *,std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n"
    "    std::basic_string< char >::__setitem__(PySliceObject *)\n"
    "    std::basic_string< char >::__setitem__(std::basic_string< char >::difference_type,std::basic_string< char >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string_insert__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::iterator arg2 ;
  std::basic_string< char >::size_type arg3 ;
  char arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_insert" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_insert" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_insert" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "string_insert" "', argument " "3"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg3 = static_cast< std::basic_string< char >::size_type >(val3);
  ecode4 = SWIG_AsVal_char(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_insert" "', argument " "4"" of type '" "char""'");
  } 
  arg4 = static_cast< char >(val4);
  (arg1)->insert(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_insert", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_string_insert__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_string_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_string_insert__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_string_insert__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_string_insert__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_string_insert__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_string_insert__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::insert(std::basic_string< char >::size_type,std::basic_string< char > const &)\n"
    "    std::basic_string< char >::insert(std::basic_string< char >::size_type,std::basic_string< char > const &,std::basic_string< char >::size_type,std::basic_string< char >::size_type)\n"
    "    std::basic_string< char >::insert(std::basic_string< char >::size_type,char const *,std::basic_string< char >::size_type)\n"
    "    std::basic_string< char >::insert(std::basic_string< char >::size_type,std::basic_string< char >::size_type,char)\n"
    "    std::basic_string< char >::insert(std::basic_string< char >::iterator,std::basic_string< char >::value_type)\n"
    "    std::basic_string< char >::insert(std::basic_string< char >::iterator,std::basic_string< char >::size_type,std::basic_string< char >::value_type)\n"
    "    std::basic_string< char >::insert(std::basic_string< char >::iterator,std::basic_string< char >::size_type,char)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string_replace__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::iterator arg2 ;
  std::basic_string< char >::iterator arg3 ;
  std::basic_string< char > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  int res4 = SWIG_OLDOBJ ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_replace" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::iterator""'");
    }
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res4 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "string_replace" "', argument " "4"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string_replace" "', argument " "4"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg4 = ptr;
  }
  result = (std::basic_string< char > *) &(arg1)->replace(arg2,arg3,(std::basic_string< char > const &)*arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_replace__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::iterator arg2 ;
  std::basic_string< char >::iterator arg3 ;
  char *arg4 = (char *) 0 ;
  std::basic_string< char >::size_type arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_replace" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::iterator""'");
    }
  }
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "string_replace" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "string_replace" "', argument " "5"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg5 = static_cast< std::basic_string< char >::size_type >(val5);
  result = (std::basic_string< char > *) &(arg1)->replace(arg2,arg3,(char const *)arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_replace__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::iterator arg2 ;
  std::basic_string< char >::iterator arg3 ;
  std::basic_string< char >::size_type arg4 ;
  char arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  char val5 ;
  int ecode5 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_replace" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::iterator""'");
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "string_replace" "', argument " "4"" of type '" "std::basic_string< char >::size_type""'");
  } 
  arg4 = static_cast< std::basic_string< char >::size_type >(val4);
  ecode5 = SWIG_AsVal_char(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "string_replace" "', argument " "5"" of type '" "char""'");
  } 
  arg5 = static_cast< char >(val5);
  result = (std::basic_string< char > *) &(arg1)->replace(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_replace__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::iterator arg2 ;
  std::basic_string< char >::iterator arg3 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_replace" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::iterator""'");
    }
  }
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "string_replace" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "string_replace" "', argument " "5"" of type '" "char const *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  result = (std::basic_string< char > *) &(arg1)->replace(arg2,arg3,(char const *)arg4,(char const *)arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_replace__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char >::iterator arg2 ;
  std::basic_string< char >::iterator arg3 ;
  std::basic_string< char >::const_iterator arg4 ;
  std::basic_string< char >::const_iterator arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  swig::SwigPyIterator *iter4 = 0 ;
  int res4 ;
  swig::SwigPyIterator *iter5 = 0 ;
  int res5 ;
  std::basic_string< char > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_replace" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "2"" of type '" "std::basic_string< char >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "3"" of type '" "std::basic_string< char >::iterator""'");
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], SWIG_as_voidptrptr(&iter4), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res4) || !iter4) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "4"" of type '" "std::basic_string< char >::const_iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::const_iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::const_iterator > *>(iter4);
    if (iter_t) {
      arg4 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "4"" of type '" "std::basic_string< char >::const_iterator""'");
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], SWIG_as_voidptrptr(&iter5), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res5) || !iter5) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "5"" of type '" "std::basic_string< char >::const_iterator""'");
  } else {
    swig::SwigPyIterator_T<std::basic_string< char >::const_iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::const_iterator > *>(iter5);
    if (iter_t) {
      arg5 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "string_replace" "', argument " "5"" of type '" "std::basic_string< char >::const_iterator""'");
    }
  }
  result = (std::basic_string< char > *) &(arg1)->replace(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_replace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "string_replace", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter) != 0));
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_string_replace__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_string_replace__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter) != 0));
        if (_v) {
          swig::SwigPyIterator *iter = 0;
          int res = SWIG_ConvertPtr(argv[3], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
          _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::const_iterator > *>(iter) != 0));
          if (_v) {
            swig::SwigPyIterator *iter = 0;
            int res = SWIG_ConvertPtr(argv[4], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
            _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::const_iterator > *>(iter) != 0));
            if (_v) {
              return _wrap_string_replace__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter) != 0));
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_string_replace__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter) != 0));
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_string_replace__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::basic_string< char >::iterator > *>(iter) != 0));
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_string_replace__SWIG_7(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_string_replace__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_string_replace__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_string_replace__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'string_replace'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_string< char >::replace(std::basic_string< char >::size_type,std::basic_string< char >::size_type,std::basic_string< char > const &)\n"
    "    std::basic_string< char >::replace(std::basic_string< char >::size_type,std::basic_string< char >::size_type,std::basic_string< char > const &,std::basic_string< char >::size_type,std::basic_string< char >::size_type)\n"
    "    std::basic_string< char >::replace(std::basic_string< char >::size_type,std::basic_string< char >::size_type,char const *,std::basic_string< char >::size_type)\n"
    "    std::basic_string< char >::replace(std::basic_string< char >::size_type,std::basic_string< char >::size_type,std::basic_string< char >::size_type,char)\n"
    "    std::basic_string< char >::replace(std::basic_string< char >::iterator,std::basic_string< char >::iterator,std::basic_string< char > const &)\n"
    "    std::basic_string< char >::replace(std::basic_string< char >::iterator,std::basic_string< char >::iterator,char const *,std::basic_string< char >::size_type)\n"
    "    std::basic_string< char >::replace(std::basic_string< char >::iterator,std::basic_string< char >::iterator,std::basic_string< char >::size_type,char)\n"
    "    std::basic_string< char >::replace(std::basic_string< char >::iterator,std::basic_string< char >::iterator,char const *,char const *)\n"
    "    std::basic_string< char >::replace(std::basic_string< char >::iterator,std::basic_string< char >::iterator,std::basic_string< char >::const_iterator,std::basic_string< char >::const_iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_string___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::basic_string< char > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "string___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___iadd__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string___iadd__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string___iadd__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (std::basic_string< char > *) &(arg1)->operator +=((std::basic_string< char > const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::basic_string< char,std::char_traits< char >,std::allocator< char > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "string___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___add__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string___add__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string___add__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (std::basic_string< char,std::char_traits< char >,std::allocator< char > > *)std_basic_string_Sl_char_Sg____add__(arg1,(std::basic_string< char > const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_string___radd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::basic_string< char,std::char_traits< char >,std::allocator< char > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "string___radd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___radd__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string___radd__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string___radd__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (std::basic_string< char,std::char_traits< char >,std::allocator< char > > *)std_basic_string_Sl_char_Sg____radd__(arg1,(std::basic_string< char > const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_string___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::basic_string< char,std::char_traits< char >,std::allocator< char > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___str__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  result = std_basic_string_Sl_char_Sg____str__(arg1);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_string___rlshift__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "string___rlshift__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___rlshift__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string___rlshift__" "', argument " "2"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string___rlshift__" "', argument " "2"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'"); 
  }
  arg2 = reinterpret_cast< std::basic_ostream< char,std::char_traits< char > > * >(argp2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &std_basic_string_Sl_char_Sg____rlshift__(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_string___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "string___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___eq__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string___eq__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string___eq__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_basic_string_Sl_char_Sg__operator_Se__Se_(arg1,(std::basic_string< char > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_string___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "string___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___ne__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string___ne__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string___ne__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_basic_string_Sl_char_Sg__operator_SN__Se_(arg1,(std::basic_string< char > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_string___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "string___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___gt__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string___gt__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string___gt__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_basic_string_Sl_char_Sg__operator_Sg_(arg1,(std::basic_string< char > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_string___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "string___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___lt__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string___lt__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string___lt__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_basic_string_Sl_char_Sg__operator_Sl_(arg1,(std::basic_string< char > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_string___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "string___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___ge__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string___ge__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string___ge__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_basic_string_Sl_char_Sg__operator_Sg__Se_(arg1,(std::basic_string< char > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_string___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  std::basic_string< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "string___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string___le__" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string___le__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "string___le__" "', argument " "2"" of type '" "std::basic_string< char > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_basic_string_Sl_char_Sg__operator_Sl__Se_(arg1,(std::basic_string< char > const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_string< char > *arg1 = (std::basic_string< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_string" "', argument " "1"" of type '" "std::basic_string< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_string< char > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *string_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *string_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ostream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char,std::char_traits< char > > *arg1 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::basic_ostream< char > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ostream" "', argument " "1"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp1);
  result = (std::basic_ostream< char > *)new std::basic_ostream< char >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ostream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ostream" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ostream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ostream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ostringstream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ios_base::openmode arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  std::basic_ostringstream< char > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ios_base__openmode,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ostringstream" "', argument " "1"" of type '" "std::ios_base::openmode""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ostringstream" "', argument " "1"" of type '" "std::ios_base::openmode""'");
    } else {
      std::ios_base::openmode * temp = reinterpret_cast< std::ios_base::openmode * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (std::basic_ostringstream< char > *)new std::basic_ostringstream< char >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ostringstream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::basic_ostringstream< char > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (std::basic_ostringstream< char > *)new std::basic_ostringstream< char >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ostringstream(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ostringstream", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ostringstream__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__ios_base__openmode, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ostringstream__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ostringstream'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_ostringstream< char >::basic_ostringstream(std::ios_base::openmode)\n"
    "    std::basic_ostringstream< char >::basic_ostringstream()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ostringstream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostringstream< char > *arg1 = (std::basic_ostringstream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ostringstream" "', argument " "1"" of type '" "std::basic_ostringstream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostringstream< char > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostringstream_str__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_ostringstream< char > *arg1 = (std::basic_ostringstream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::basic_string< char,std::char_traits< char >,std::allocator< char > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostringstream_str" "', argument " "1"" of type '" "std::basic_ostringstream< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostringstream< char > * >(argp1);
  result = ((std::basic_ostringstream< char > const *)arg1)->str();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostringstream_str__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::basic_ostringstream< char > *arg1 = (std::basic_ostringstream< char > *) 0 ;
  std::basic_string< char,std::char_traits< char >,std::allocator< char > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostringstream_str" "', argument " "1"" of type '" "std::basic_ostringstream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostringstream< char > * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostringstream_str" "', argument " "2"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ostringstream_str" "', argument " "2"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->str((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostringstream_str(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ostringstream_str", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ostringstream_str__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ostringstream_str__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ostringstream_str'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_ostringstream< char >::str() const\n"
    "    std::basic_ostringstream< char >::str(std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *ostringstream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ostringstream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_endl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char,std::char_traits< char > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "endl" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "endl" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char,std::char_traits< char > > * >(argp1);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &std::SWIGTEMPLATEDISAMBIGUATOR endl< char,std::char_traits< char > >(*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char,std::char_traits< char > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "flush" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "flush" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char,std::char_traits< char > > * >(argp1);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &std::SWIGTEMPLATEDISAMBIGUATOR flush< char,std::char_traits< char > >(*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_cout_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable cout is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_cout_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&std::cout), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_cerr_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable cerr is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_cerr_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&std::cerr), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_clog_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable clog is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_clog_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&std::clog), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_ListWrapperSBMLNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ListWrapperSBMLNamespaces", 0, 0, 0)) SWIG_fail;
  result = (ListWrapper< SBMLNamespaces > *)new ListWrapper< SBMLNamespaces >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListWrapperSBMLNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListWrapperSBMLNamespaces" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperSBMLNamespaces_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperSBMLNamespaces_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperSBMLNamespaces_add" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListWrapperSBMLNamespaces_add" "', argument " "2"" of type '" "SBMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperSBMLNamespaces_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBMLNamespaces *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperSBMLNamespaces_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperSBMLNamespaces_get" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListWrapperSBMLNamespaces_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBMLNamespaces *)((ListWrapper< SBMLNamespaces > const *)arg1)->get(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperSBMLNamespaces_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperSBMLNamespaces_prepend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperSBMLNamespaces_prepend" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListWrapperSBMLNamespaces_prepend" "', argument " "2"" of type '" "SBMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces * >(argp2);
  (arg1)->prepend(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperSBMLNamespaces_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBMLNamespaces *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperSBMLNamespaces_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperSBMLNamespaces_remove" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListWrapperSBMLNamespaces_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBMLNamespaces *)(arg1)->remove(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperSBMLNamespaces_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperSBMLNamespaces_getSize" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  result = (unsigned int)((ListWrapper< SBMLNamespaces > const *)arg1)->getSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperSBMLNamespaces___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBMLNamespaces > *arg1 = (ListWrapper< SBMLNamespaces > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperSBMLNamespaces___len__" "', argument " "1"" of type '" "ListWrapper< SBMLNamespaces > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBMLNamespaces > * >(argp1);
  result = (int)ListWrapper_Sl_SBMLNamespaces_Sg____len__(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListWrapperSBMLNamespaces_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListWrapperSBMLNamespaces_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListWrapperCVTerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ListWrapperCVTerm", 0, 0, 0)) SWIG_fail;
  result = (ListWrapper< CVTerm > *)new ListWrapper< CVTerm >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListWrapperT_CVTerm_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListWrapperCVTerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListWrapperCVTerm" "', argument " "1"" of type '" "ListWrapper< CVTerm > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperCVTerm_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  CVTerm *arg2 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperCVTerm_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperCVTerm_add" "', argument " "1"" of type '" "ListWrapper< CVTerm > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListWrapperCVTerm_add" "', argument " "2"" of type '" "CVTerm *""'"); 
  }
  arg2 = reinterpret_cast< CVTerm * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperCVTerm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  CVTerm *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperCVTerm_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperCVTerm_get" "', argument " "1"" of type '" "ListWrapper< CVTerm > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListWrapperCVTerm_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CVTerm *)((ListWrapper< CVTerm > const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperCVTerm_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  CVTerm *arg2 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperCVTerm_prepend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperCVTerm_prepend" "', argument " "1"" of type '" "ListWrapper< CVTerm > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListWrapperCVTerm_prepend" "', argument " "2"" of type '" "CVTerm *""'"); 
  }
  arg2 = reinterpret_cast< CVTerm * >(argp2);
  (arg1)->prepend(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperCVTerm_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  CVTerm *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperCVTerm_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperCVTerm_remove" "', argument " "1"" of type '" "ListWrapper< CVTerm > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListWrapperCVTerm_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CVTerm *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperCVTerm_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperCVTerm_getSize" "', argument " "1"" of type '" "ListWrapper< CVTerm > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  result = (unsigned int)((ListWrapper< CVTerm > const *)arg1)->getSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperCVTerm___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< CVTerm > *arg1 = (ListWrapper< CVTerm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperCVTerm___len__" "', argument " "1"" of type '" "ListWrapper< CVTerm > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< CVTerm > * >(argp1);
  result = (int)ListWrapper_Sl_CVTerm_Sg____len__(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListWrapperCVTerm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListWrapperT_CVTerm_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListWrapperCVTerm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListWrapperDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ListWrapperDate", 0, 0, 0)) SWIG_fail;
  result = (ListWrapper< Date > *)new ListWrapper< Date >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListWrapperT_Date_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListWrapperDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListWrapperDate" "', argument " "1"" of type '" "ListWrapper< Date > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperDate_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  Date *arg2 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperDate_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperDate_add" "', argument " "1"" of type '" "ListWrapper< Date > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListWrapperDate_add" "', argument " "2"" of type '" "Date *""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperDate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Date *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperDate_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperDate_get" "', argument " "1"" of type '" "ListWrapper< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListWrapperDate_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Date *)((ListWrapper< Date > const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperDate_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  Date *arg2 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperDate_prepend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperDate_prepend" "', argument " "1"" of type '" "ListWrapper< Date > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListWrapperDate_prepend" "', argument " "2"" of type '" "Date *""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  (arg1)->prepend(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperDate_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Date *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperDate_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperDate_remove" "', argument " "1"" of type '" "ListWrapper< Date > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListWrapperDate_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Date *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperDate_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperDate_getSize" "', argument " "1"" of type '" "ListWrapper< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  result = (unsigned int)((ListWrapper< Date > const *)arg1)->getSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperDate___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< Date > *arg1 = (ListWrapper< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperDate___len__" "', argument " "1"" of type '" "ListWrapper< Date > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< Date > * >(argp1);
  result = (int)ListWrapper_Sl_Date_Sg____len__(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListWrapperDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListWrapperT_Date_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListWrapperDate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListWrapperModelCreator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ListWrapperModelCreator", 0, 0, 0)) SWIG_fail;
  result = (ListWrapper< ModelCreator > *)new ListWrapper< ModelCreator >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListWrapperT_ModelCreator_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListWrapperModelCreator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListWrapperModelCreator" "', argument " "1"" of type '" "ListWrapper< ModelCreator > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperModelCreator_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  ModelCreator *arg2 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperModelCreator_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperModelCreator_add" "', argument " "1"" of type '" "ListWrapper< ModelCreator > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListWrapperModelCreator_add" "', argument " "2"" of type '" "ModelCreator *""'"); 
  }
  arg2 = reinterpret_cast< ModelCreator * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperModelCreator_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ModelCreator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperModelCreator_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperModelCreator_get" "', argument " "1"" of type '" "ListWrapper< ModelCreator > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListWrapperModelCreator_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ModelCreator *)((ListWrapper< ModelCreator > const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelCreator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperModelCreator_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  ModelCreator *arg2 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperModelCreator_prepend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperModelCreator_prepend" "', argument " "1"" of type '" "ListWrapper< ModelCreator > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListWrapperModelCreator_prepend" "', argument " "2"" of type '" "ModelCreator *""'"); 
  }
  arg2 = reinterpret_cast< ModelCreator * >(argp2);
  (arg1)->prepend(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperModelCreator_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ModelCreator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperModelCreator_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperModelCreator_remove" "', argument " "1"" of type '" "ListWrapper< ModelCreator > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListWrapperModelCreator_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ModelCreator *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelCreator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperModelCreator_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperModelCreator_getSize" "', argument " "1"" of type '" "ListWrapper< ModelCreator > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  result = (unsigned int)((ListWrapper< ModelCreator > const *)arg1)->getSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperModelCreator___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< ModelCreator > *arg1 = (ListWrapper< ModelCreator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_ModelCreator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperModelCreator___len__" "', argument " "1"" of type '" "ListWrapper< ModelCreator > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< ModelCreator > * >(argp1);
  result = (int)ListWrapper_Sl_ModelCreator_Sg____len__(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListWrapperModelCreator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListWrapperT_ModelCreator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListWrapperModelCreator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListWrapperSBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ListWrapperSBase", 0, 0, 0)) SWIG_fail;
  result = (ListWrapper< SBase > *)new ListWrapper< SBase >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListWrapperT_SBase_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListWrapperSBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListWrapperSBase" "', argument " "1"" of type '" "ListWrapper< SBase > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperSBase_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperSBase_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperSBase_add" "', argument " "1"" of type '" "ListWrapper< SBase > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListWrapperSBase_add" "', argument " "2"" of type '" "SBase *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  (arg1)->add(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperSBase_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperSBase_get", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperSBase_get" "', argument " "1"" of type '" "ListWrapper< SBase > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListWrapperSBase_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBase *)((ListWrapper< SBase > const *)arg1)->get(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperSBase_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperSBase_prepend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperSBase_prepend" "', argument " "1"" of type '" "ListWrapper< SBase > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListWrapperSBase_prepend" "', argument " "2"" of type '" "SBase *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  (arg1)->prepend(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperSBase_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListWrapperSBase_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperSBase_remove" "', argument " "1"" of type '" "ListWrapper< SBase > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListWrapperSBase_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBase *)(arg1)->remove(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperSBase_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperSBase_getSize" "', argument " "1"" of type '" "ListWrapper< SBase > const *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  result = (unsigned int)((ListWrapper< SBase > const *)arg1)->getSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListWrapperSBase___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListWrapper< SBase > *arg1 = (ListWrapper< SBase > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListWrapperT_SBase_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListWrapperSBase___len__" "', argument " "1"" of type '" "ListWrapper< SBase > *""'"); 
  }
  arg1 = reinterpret_cast< ListWrapper< SBase > * >(argp1);
  result = (int)ListWrapper_Sl_SBase_Sg____len__(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListWrapperSBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListWrapperT_SBase_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListWrapperSBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_getLibSBMLVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "getLibSBMLVersion", 0, 0, 0)) SWIG_fail;
  result = (int)getLibSBMLVersion();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getLibSBMLDottedVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "getLibSBMLDottedVersion", 0, 0, 0)) SWIG_fail;
  result = (char *)getLibSBMLDottedVersion();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getLibSBMLVersionString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "getLibSBMLVersionString", 0, 0, 0)) SWIG_fail;
  result = (char *)getLibSBMLVersionString();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_isLibSBMLCompiledWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isLibSBMLCompiledWith" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (int)isLibSBMLCompiledWith((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_getLibSBMLDependencyVersionOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getLibSBMLDependencyVersionOf" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (char *)getLibSBMLDependencyVersionOf((char const *)arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_OperationReturnValue_toString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "OperationReturnValue_toString" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (char *)OperationReturnValue_toString(arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IdList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  IdList *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (IdList *)new IdList();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IdList, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IdList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  IdList *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IdList" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IdList" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (IdList *)new IdList((std::string const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IdList, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IdList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IdList", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_IdList__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IdList__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IdList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IdList::IdList()\n"
    "    IdList::IdList(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IdList_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IdList *arg1 = (IdList *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IdList_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IdList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdList_append" "', argument " "1"" of type '" "IdList *""'"); 
  }
  arg1 = reinterpret_cast< IdList * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdList_append" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdList_append" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->append((std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IdList_contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IdList *arg1 = (IdList *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "IdList_contains", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IdList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdList_contains" "', argument " "1"" of type '" "IdList const *""'"); 
  }
  arg1 = reinterpret_cast< IdList * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdList_contains" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdList_contains" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((IdList const *)arg1)->contains((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IdList_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IdList *arg1 = (IdList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IdList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdList_empty" "', argument " "1"" of type '" "IdList const *""'"); 
  }
  arg1 = reinterpret_cast< IdList * >(argp1);
  result = (bool)((IdList const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IdList_removeIdsBefore(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IdList *arg1 = (IdList *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IdList_removeIdsBefore", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IdList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdList_removeIdsBefore" "', argument " "1"" of type '" "IdList *""'"); 
  }
  arg1 = reinterpret_cast< IdList * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdList_removeIdsBefore" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdList_removeIdsBefore" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->removeIdsBefore((std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IdList_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IdList *arg1 = (IdList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IdList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdList_size" "', argument " "1"" of type '" "IdList const *""'"); 
  }
  arg1 = reinterpret_cast< IdList * >(argp1);
  result = (unsigned int)((IdList const *)arg1)->size();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IdList_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IdList *arg1 = (IdList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IdList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdList_clear" "', argument " "1"" of type '" "IdList *""'"); 
  }
  arg1 = reinterpret_cast< IdList * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IdList_at(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IdList *arg1 = (IdList *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "IdList_at", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IdList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdList_at" "', argument " "1"" of type '" "IdList *""'"); 
  }
  arg1 = reinterpret_cast< IdList * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdList_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->at(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IdList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IdList *arg1 = (IdList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IdList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IdList" "', argument " "1"" of type '" "IdList *""'"); 
  }
  arg1 = reinterpret_cast< IdList * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IdList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_IdList, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IdList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IdentifierTransformer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  IdentifierTransformer *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (IdentifierTransformer *)new SwigDirector_IdentifierTransformer(arg1); 
  } else {
    result = (IdentifierTransformer *)new IdentifierTransformer(); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IdentifierTransformer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IdentifierTransformer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IdentifierTransformer *arg1 = (IdentifierTransformer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IdentifierTransformer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IdentifierTransformer" "', argument " "1"" of type '" "IdentifierTransformer *""'"); 
  }
  arg1 = reinterpret_cast< IdentifierTransformer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IdentifierTransformer_transform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IdentifierTransformer *arg1 = (IdentifierTransformer *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "IdentifierTransformer_transform", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IdentifierTransformer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentifierTransformer_transform" "', argument " "1"" of type '" "IdentifierTransformer *""'"); 
  }
  arg1 = reinterpret_cast< IdentifierTransformer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentifierTransformer_transform" "', argument " "2"" of type '" "SBase *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (int)(arg1)->IdentifierTransformer::transform(arg2);
    } else {
      result = (int)(arg1)->transform(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_IdentifierTransformer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IdentifierTransformer *arg1 = (IdentifierTransformer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IdentifierTransformer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_IdentifierTransformer" "', argument " "1"" of type '" "IdentifierTransformer *""'"); 
  }
  arg1 = reinterpret_cast< IdentifierTransformer * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IdentifierTransformer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_IdentifierTransformer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IdentifierTransformer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ElementFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  ElementFilter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (ElementFilter *)new SwigDirector_ElementFilter(arg1); 
  } else {
    result = (ElementFilter *)new ElementFilter(); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ElementFilter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ElementFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ElementFilter *arg1 = (ElementFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ElementFilter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ElementFilter" "', argument " "1"" of type '" "ElementFilter *""'"); 
  }
  arg1 = reinterpret_cast< ElementFilter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElementFilter_filter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ElementFilter *arg1 = (ElementFilter *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ElementFilter_filter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ElementFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementFilter_filter" "', argument " "1"" of type '" "ElementFilter *""'"); 
  }
  arg1 = reinterpret_cast< ElementFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementFilter_filter" "', argument " "2"" of type '" "SBase const *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (bool)(arg1)->ElementFilter::filter((SBase const *)arg2);
    } else {
      result = (bool)(arg1)->filter((SBase const *)arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_ElementFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ElementFilter *arg1 = (ElementFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ElementFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ElementFilter" "', argument " "1"" of type '" "ElementFilter *""'"); 
  }
  arg1 = reinterpret_cast< ElementFilter * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ElementFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ElementFilter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ElementFilter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBMLReader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLReader *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SBMLReader", 0, 0, 0)) SWIG_fail;
  result = (SBMLReader *)new SBMLReader();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLReader, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLReader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLReader *arg1 = (SBMLReader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLReader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLReader" "', argument " "1"" of type '" "SBMLReader *""'"); 
  }
  arg1 = reinterpret_cast< SBMLReader * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLReader_readSBML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLReader *arg1 = (SBMLReader *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBMLDocument *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLReader_readSBML", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLReader_readSBML" "', argument " "1"" of type '" "SBMLReader *""'"); 
  }
  arg1 = reinterpret_cast< SBMLReader * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLReader_readSBML" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLReader_readSBML" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBMLDocument *)(arg1)->readSBML((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLReader_readSBMLFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLReader *arg1 = (SBMLReader *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBMLDocument *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLReader_readSBMLFromFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLReader_readSBMLFromFile" "', argument " "1"" of type '" "SBMLReader *""'"); 
  }
  arg1 = reinterpret_cast< SBMLReader * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLReader_readSBMLFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLReader_readSBMLFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBMLDocument *)(arg1)->readSBMLFromFile((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLReader_readSBMLFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLReader *arg1 = (SBMLReader *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBMLDocument *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLReader_readSBMLFromString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLReader_readSBMLFromString" "', argument " "1"" of type '" "SBMLReader *""'"); 
  }
  arg1 = reinterpret_cast< SBMLReader * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLReader_readSBMLFromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLReader_readSBMLFromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBMLDocument *)(arg1)->readSBMLFromString((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLReader_hasZlib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLReader_hasZlib", 0, 0, 0)) SWIG_fail;
  result = (bool)SBMLReader::hasZlib();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLReader_hasBzip2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLReader_hasBzip2", 0, 0, 0)) SWIG_fail;
  result = (bool)SBMLReader::hasBzip2();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLReader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLReader, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLReader_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_readSBMLFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLDocument_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "readSBMLFromFile" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (SBMLDocument_t *)readSBMLFromFile((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_readSBMLFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLDocument_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "readSBMLFromString" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (SBMLDocument_t *)readSBMLFromString((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLWriter *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SBMLWriter", 0, 0, 0)) SWIG_fail;
  result = (SBMLWriter *)new SBMLWriter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLWriter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLWriter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLWriter" "', argument " "1"" of type '" "SBMLWriter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLWriter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLWriter_setProgramName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLWriter_setProgramName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLWriter_setProgramName" "', argument " "1"" of type '" "SBMLWriter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLWriter * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLWriter_setProgramName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLWriter_setProgramName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setProgramName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLWriter_setProgramVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLWriter_setProgramVersion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLWriter_setProgramVersion" "', argument " "1"" of type '" "SBMLWriter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLWriter * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLWriter_setProgramVersion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLWriter_setProgramVersion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setProgramVersion((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLWriter_writeSBML__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLWriter_writeSBML" "', argument " "1"" of type '" "SBMLWriter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLWriter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLWriter_writeSBML" "', argument " "2"" of type '" "SBMLDocument const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBMLWriter_writeSBML" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLWriter_writeSBML" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->writeSBML((SBMLDocument const *)arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLWriter_writeSBML__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  std::ostream *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLWriter_writeSBML" "', argument " "1"" of type '" "SBMLWriter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLWriter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLWriter_writeSBML" "', argument " "2"" of type '" "SBMLDocument const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBMLWriter_writeSBML" "', argument " "3"" of type '" "std::ostream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLWriter_writeSBML" "', argument " "3"" of type '" "std::ostream &""'"); 
  }
  arg3 = reinterpret_cast< std::ostream * >(argp3);
  result = (bool)(arg1)->writeSBML((SBMLDocument const *)arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLWriter_writeSBML(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLWriter_writeSBML", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLWriter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SBMLDocument, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBMLWriter_writeSBML__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLWriter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SBMLDocument, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBMLWriter_writeSBML__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLWriter_writeSBML'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLWriter::writeSBML(SBMLDocument const *,std::string const &)\n"
    "    SBMLWriter::writeSBML(SBMLDocument const *,std::ostream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLWriter_writeToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLWriter_writeToString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLWriter_writeToString" "', argument " "1"" of type '" "SBMLWriter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLWriter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLWriter_writeToString" "', argument " "2"" of type '" "SBMLDocument const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  result = (char *)(arg1)->writeToString((SBMLDocument const *)arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLWriter_writeSBMLToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLWriter_writeSBMLToFile", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLWriter_writeSBMLToFile" "', argument " "1"" of type '" "SBMLWriter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLWriter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLWriter_writeSBMLToFile" "', argument " "2"" of type '" "SBMLDocument const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBMLWriter_writeSBMLToFile" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLWriter_writeSBMLToFile" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->writeSBMLToFile((SBMLDocument const *)arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLWriter_writeSBMLToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLWriter *arg1 = (SBMLWriter *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLWriter_writeSBMLToString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLWriter_writeSBMLToString" "', argument " "1"" of type '" "SBMLWriter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLWriter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLWriter_writeSBMLToString" "', argument " "2"" of type '" "SBMLDocument const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  result = (char *)(arg1)->writeSBMLToString((SBMLDocument const *)arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLWriter_hasZlib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLWriter_hasZlib", 0, 0, 0)) SWIG_fail;
  result = (bool)SBMLWriter::hasZlib();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLWriter_hasBzip2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLWriter_hasBzip2", 0, 0, 0)) SWIG_fail;
  result = (bool)SBMLWriter::hasBzip2();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLWriter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLWriter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLWriter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_writeSBML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument_t *arg1 = (SBMLDocument_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "writeSBML", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeSBML" "', argument " "1"" of type '" "SBMLDocument_t const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument_t * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writeSBML" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)writeSBML((SBMLDocument const *)arg1,(char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_writeSBMLToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument_t *arg1 = (SBMLDocument_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeSBMLToString" "', argument " "1"" of type '" "SBMLDocument_t const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument_t * >(argp1);
  result = (char *)writeSBMLToString((SBMLDocument const *)arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_writeSBMLToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument_t *arg1 = (SBMLDocument_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "writeSBMLToFile", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeSBMLToFile" "', argument " "1"" of type '" "SBMLDocument_t const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument_t * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writeSBMLToFile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)writeSBMLToFile((SBMLDocument const *)arg1,(char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLTypeCode_toString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  char *arg2 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLTypeCode_toString", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBMLTypeCode_toString" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLTypeCode_toString" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (char *)SBMLTypeCode_toString(arg1,(char const *)arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBase" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBase *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_clone" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (SBase *)((SBase const *)arg1)->clone();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getElementBySId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SBase *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getElementBySId" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getElementBySId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SBase *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getElementBySId" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)((SBase const *)arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getElementBySId(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getElementBySId", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_getElementBySId__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_getElementBySId__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getElementBySId'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getElementBySId(std::string const &)\n"
    "    SBase::getElementBySId(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getElementByMetaId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SBase *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getElementByMetaId" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementByMetaId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getElementByMetaId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SBase *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getElementByMetaId" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)((SBase const *)arg1)->getElementByMetaId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getElementByMetaId(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getElementByMetaId", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_getElementByMetaId__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_getElementByMetaId__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getElementByMetaId'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getElementByMetaId(std::string const &)\n"
    "    SBase::getElementByMetaId(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_renameSIdRefs" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBase_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_renameMetaIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_renameMetaIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_renameMetaIdRefs" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_renameMetaIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_renameMetaIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBase_renameMetaIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_renameMetaIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameMetaIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_renameUnitSIdRefs" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBase_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_replaceSIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_replaceSIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_replaceSIDWithFunction" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBase_replaceSIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceSIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_divideAssignmentsToSIdByFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_divideAssignmentsToSIdByFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_divideAssignmentsToSIdByFunction" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_divideAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_divideAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBase_divideAssignmentsToSIdByFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->divideAssignmentsToSIdByFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_multiplyAssignmentsToSIdByFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_multiplyAssignmentsToSIdByFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_multiplyAssignmentsToSIdByFunction" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_multiplyAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_multiplyAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBase_multiplyAssignmentsToSIdByFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->multiplyAssignmentsToSIdByFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getElementFromPluginsBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_getElementFromPluginsBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getElementFromPluginsBySId" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBase_getElementFromPluginsBySId" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (SBase *)(arg1)->getElementFromPluginsBySId(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getElementFromPluginsByMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_getElementFromPluginsByMetaId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getElementFromPluginsByMetaId" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBase_getElementFromPluginsByMetaId" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (SBase *)(arg1)->getElementFromPluginsByMetaId(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_hasNonstandardIdentifierBeginningWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_hasNonstandardIdentifierBeginningWith", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_hasNonstandardIdentifierBeginningWith" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_hasNonstandardIdentifierBeginningWith" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_hasNonstandardIdentifierBeginningWith" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->hasNonstandardIdentifierBeginningWith((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_prependStringToAllIdentifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_prependStringToAllIdentifiers", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_prependStringToAllIdentifiers" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_prependStringToAllIdentifiers" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_prependStringToAllIdentifiers" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->prependStringToAllIdentifiers((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_transformIdentifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  IdentifierTransformer *arg2 = (IdentifierTransformer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_transformIdentifiers", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_transformIdentifiers" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_IdentifierTransformer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_transformIdentifiers" "', argument " "2"" of type '" "IdentifierTransformer *""'"); 
  }
  arg2 = reinterpret_cast< IdentifierTransformer * >(argp2);
  result = (int)(arg1)->transformIdentifiers(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getMetaId" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (std::string *) &((SBase const *)arg1)->getMetaId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getId" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (std::string *) &((SBase const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getIdAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getIdAttribute" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (std::string *) &((SBase const *)arg1)->getIdAttribute();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getName" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (std::string *) &((SBase const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getNotes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getNotes" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (XMLNode *)(arg1)->getNotes();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getNotes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getNotes" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (XMLNode *)((SBase const *)arg1)->getNotes();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getNotes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getNotes", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getNotes__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getNotes__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getNotes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getNotes()\n"
    "    SBase::getNotes() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getNotesString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getNotesString" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (arg1)->getNotesString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getNotesString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getNotesString" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = ((SBase const *)arg1)->getNotesString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getNotesString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getNotesString", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getNotesString__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getNotesString__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getNotesString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getNotesString()\n"
    "    SBase::getNotesString() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getAnnotation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getAnnotation" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (XMLNode *)(arg1)->getAnnotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getAnnotation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getAnnotation" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (XMLNode *)((SBase const *)arg1)->getAnnotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getAnnotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getAnnotation", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getAnnotation__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getAnnotation__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getAnnotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getAnnotation()\n"
    "    SBase::getAnnotation() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getAnnotationString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getAnnotationString" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (arg1)->getAnnotationString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getAnnotationString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getAnnotationString" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = ((SBase const *)arg1)->getAnnotationString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getAnnotationString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getAnnotationString", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getAnnotationString__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getAnnotationString__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getAnnotationString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getAnnotationString()\n"
    "    SBase::getAnnotationString() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNamespaces *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getNamespaces" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (XMLNamespaces *)((SBase const *)arg1)->getNamespaces();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getSBMLDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getSBMLDocument" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (SBMLDocument *)((SBase const *)arg1)->getSBMLDocument();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getSBMLDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getSBMLDocument" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (SBMLDocument *)(arg1)->getSBMLDocument();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getSBMLDocument(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getSBMLDocument", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getSBMLDocument__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getSBMLDocument__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getSBMLDocument'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getSBMLDocument() const\n"
    "    SBase::getSBMLDocument()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getParentSBMLObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBase *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getParentSBMLObject" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (SBase *)(arg1)->getParentSBMLObject();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getParentSBMLObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBase *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getParentSBMLObject" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (SBase *)((SBase const *)arg1)->getParentSBMLObject();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getParentSBMLObject(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getParentSBMLObject", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getParentSBMLObject__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getParentSBMLObject__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getParentSBMLObject'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getParentSBMLObject()\n"
    "    SBase::getParentSBMLObject() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getAncestorOfType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  SBase *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getAncestorOfType" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBase_getAncestorOfType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBase_getAncestorOfType" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_getAncestorOfType" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (SBase *)(arg1)->getAncestorOfType(arg2,(std::string const &)*arg3);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getAncestorOfType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SBase *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getAncestorOfType" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBase_getAncestorOfType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SBase *)(arg1)->getAncestorOfType(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getAncestorOfType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  int arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SBase *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getAncestorOfType" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBase_getAncestorOfType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBase_getAncestorOfType" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (SBase *)((SBase const *)arg1)->getAncestorOfType(arg2,arg3);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getAncestorOfType__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SBase *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getAncestorOfType" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBase_getAncestorOfType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SBase *)((SBase const *)arg1)->getAncestorOfType(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getAncestorOfType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getAncestorOfType", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBase_getAncestorOfType__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBase_getAncestorOfType__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBase_getAncestorOfType__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBase_getAncestorOfType__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getAncestorOfType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getAncestorOfType(int,std::string const &)\n"
    "    SBase::getAncestorOfType(int)\n"
    "    SBase::getAncestorOfType(int,std::string const) const\n"
    "    SBase::getAncestorOfType(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getSBOTerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getSBOTerm" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)((SBase const *)arg1)->getSBOTerm();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getSBOTermID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getSBOTermID" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = ((SBase const *)arg1)->getSBOTermID();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getSBOTermAsURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getSBOTermAsURL" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = ((SBase const *)arg1)->getSBOTermAsURL();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getLine" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (unsigned int)((SBase const *)arg1)->getLine();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getColumn" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (unsigned int)((SBase const *)arg1)->getColumn();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getModelHistory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ModelHistory *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getModelHistory" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (ModelHistory *)((SBase const *)arg1)->getModelHistory();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelHistory, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getModelHistory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ModelHistory *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getModelHistory" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (ModelHistory *)(arg1)->getModelHistory();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelHistory, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getModelHistory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getModelHistory", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getModelHistory__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getModelHistory__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getModelHistory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getModelHistory() const\n"
    "    SBase::getModelHistory()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_isSetMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isSetMetaId" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)((SBase const *)arg1)->isSetMetaId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isSetId" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)((SBase const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_isSetIdAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isSetIdAttribute" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)((SBase const *)arg1)->isSetIdAttribute();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isSetName" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)((SBase const *)arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_isSetNotes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isSetNotes" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)((SBase const *)arg1)->isSetNotes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_isSetAnnotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isSetAnnotation" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)((SBase const *)arg1)->isSetAnnotation();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_isSetSBOTerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isSetSBOTerm" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)((SBase const *)arg1)->isSetSBOTerm();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_setMetaId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setMetaId" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_setMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setMetaId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_isSetModelHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isSetModelHistory" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)(arg1)->isSetModelHistory();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setId" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setIdAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_setIdAttribute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setIdAttribute" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setIdAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_setIdAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setIdAttribute((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setName" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setAnnotation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setAnnotation" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setAnnotation" "', argument " "2"" of type '" "XMLNode const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  result = (int)(arg1)->setAnnotation((XMLNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setAnnotation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setAnnotation" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setAnnotation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_setAnnotation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setAnnotation((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setAnnotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_setAnnotation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_setAnnotation__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_setAnnotation__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_setAnnotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::setAnnotation(XMLNode const *)\n"
    "    SBase::setAnnotation(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_appendAnnotation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_appendAnnotation" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_appendAnnotation" "', argument " "2"" of type '" "XMLNode const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  result = (int)(arg1)->appendAnnotation((XMLNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_appendAnnotation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_appendAnnotation" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_appendAnnotation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_appendAnnotation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->appendAnnotation((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_appendAnnotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_appendAnnotation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_appendAnnotation__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_appendAnnotation__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_appendAnnotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::appendAnnotation(XMLNode const *)\n"
    "    SBase::appendAnnotation(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_removeTopLevelAnnotationElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_removeTopLevelAnnotationElement" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_removeTopLevelAnnotationElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_removeTopLevelAnnotationElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBase_removeTopLevelAnnotationElement" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBase_removeTopLevelAnnotationElement" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (int)(arg1)->removeTopLevelAnnotationElement((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_removeTopLevelAnnotationElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_removeTopLevelAnnotationElement" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_removeTopLevelAnnotationElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_removeTopLevelAnnotationElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBase_removeTopLevelAnnotationElement" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->removeTopLevelAnnotationElement((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_removeTopLevelAnnotationElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_removeTopLevelAnnotationElement" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_removeTopLevelAnnotationElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_removeTopLevelAnnotationElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->removeTopLevelAnnotationElement((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_removeTopLevelAnnotationElement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_removeTopLevelAnnotationElement", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_removeTopLevelAnnotationElement__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBase_removeTopLevelAnnotationElement__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBase_removeTopLevelAnnotationElement__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_removeTopLevelAnnotationElement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::removeTopLevelAnnotationElement(std::string const &,std::string const,bool)\n"
    "    SBase::removeTopLevelAnnotationElement(std::string const &,std::string const)\n"
    "    SBase::removeTopLevelAnnotationElement(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_replaceTopLevelAnnotationElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_replaceTopLevelAnnotationElement" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_replaceTopLevelAnnotationElement" "', argument " "2"" of type '" "XMLNode const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  result = (int)(arg1)->replaceTopLevelAnnotationElement((XMLNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_replaceTopLevelAnnotationElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_replaceTopLevelAnnotationElement" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_replaceTopLevelAnnotationElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_replaceTopLevelAnnotationElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->replaceTopLevelAnnotationElement((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_replaceTopLevelAnnotationElement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_replaceTopLevelAnnotationElement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_replaceTopLevelAnnotationElement__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_replaceTopLevelAnnotationElement__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_replaceTopLevelAnnotationElement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::replaceTopLevelAnnotationElement(XMLNode const *)\n"
    "    SBase::replaceTopLevelAnnotationElement(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_setNotes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setNotes" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setNotes" "', argument " "2"" of type '" "XMLNode const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  result = (int)(arg1)->setNotes((XMLNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setNotes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setNotes" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setNotes" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_setNotes" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBase_setNotes" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (int)(arg1)->setNotes((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setNotes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setNotes" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setNotes" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_setNotes" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setNotes((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setNotes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_setNotes", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_setNotes__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_setNotes__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBase_setNotes__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_setNotes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::setNotes(XMLNode const *)\n"
    "    SBase::setNotes(std::string const &,bool)\n"
    "    SBase::setNotes(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_appendNotes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_appendNotes" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_appendNotes" "', argument " "2"" of type '" "XMLNode const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  result = (int)(arg1)->appendNotes((XMLNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_appendNotes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_appendNotes" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_appendNotes" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_appendNotes" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->appendNotes((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_appendNotes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_appendNotes", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_appendNotes__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_appendNotes__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_appendNotes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::appendNotes(XMLNode const *)\n"
    "    SBase::appendNotes(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_setModelHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  ModelHistory *arg2 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_setModelHistory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setModelHistory" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setModelHistory" "', argument " "2"" of type '" "ModelHistory *""'"); 
  }
  arg2 = reinterpret_cast< ModelHistory * >(argp2);
  result = (int)(arg1)->setModelHistory(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_connectToParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_connectToParent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_connectToParent" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_connectToParent" "', argument " "2"" of type '" "SBase *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  (arg1)->connectToParent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_connectToChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_connectToChild" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  (arg1)->connectToChild();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setSBOTerm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setSBOTerm" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBase_setSBOTerm" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->setSBOTerm(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setSBOTerm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setSBOTerm" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setSBOTerm" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_setSBOTerm" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setSBOTerm((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setSBOTerm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_setSBOTerm", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBase_setSBOTerm__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_setSBOTerm__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_setSBOTerm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::setSBOTerm(int)\n"
    "    SBase::setSBOTerm(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_setNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  XMLNamespaces *arg2 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_setNamespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setNamespaces" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setNamespaces" "', argument " "2"" of type '" "XMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< XMLNamespaces * >(argp2);
  result = (int)(arg1)->setNamespaces(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_unsetMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_unsetMetaId" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)(arg1)->unsetMetaId();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_unsetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_unsetId" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)(arg1)->unsetId();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_unsetIdAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_unsetIdAttribute" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)(arg1)->unsetIdAttribute();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_unsetName" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_unsetNotes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_unsetNotes" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)(arg1)->unsetNotes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_unsetAnnotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_unsetAnnotation" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)(arg1)->unsetAnnotation();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_unsetSBOTerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_unsetSBOTerm" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)(arg1)->unsetSBOTerm();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_addCVTerm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  CVTerm *arg2 = (CVTerm *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_addCVTerm" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_addCVTerm" "', argument " "2"" of type '" "CVTerm *""'"); 
  }
  arg2 = reinterpret_cast< CVTerm * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBase_addCVTerm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (int)(arg1)->addCVTerm(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_addCVTerm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  CVTerm *arg2 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_addCVTerm" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_addCVTerm" "', argument " "2"" of type '" "CVTerm *""'"); 
  }
  arg2 = reinterpret_cast< CVTerm * >(argp2);
  result = (int)(arg1)->addCVTerm(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_addCVTerm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_addCVTerm", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CVTerm, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_addCVTerm__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CVTerm, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBase_addCVTerm__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_addCVTerm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::addCVTerm(CVTerm *,bool)\n"
    "    SBase::addCVTerm(CVTerm *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getCVTerms__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  List *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getCVTerms" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (List *)(arg1)->getCVTerms();
  {
    ListWrapper<CVTerm> *listw = (result != 0) ? new ListWrapper<CVTerm>(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(listw),
      
      SWIGTYPE_p_ListWrapperT_CVTerm_t,
      
      
      
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getCVTerms__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  List *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getCVTerms" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (List *)((SBase const *)arg1)->getCVTerms();
  {
    ListWrapper<CVTerm> *listw = (result != 0) ? new ListWrapper<CVTerm>(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(listw),
      
      SWIGTYPE_p_ListWrapperT_CVTerm_t,
      
      
      
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getCVTerms(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getCVTerms", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getCVTerms__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getCVTerms__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getCVTerms'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getCVTerms()\n"
    "    SBase::getCVTerms() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getNumCVTerms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getNumCVTerms" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (unsigned int)(arg1)->getNumCVTerms();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getCVTerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  CVTerm *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_getCVTerm", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getCVTerm" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBase_getCVTerm" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CVTerm *)(arg1)->getCVTerm(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_unsetCVTerms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_unsetCVTerms" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)(arg1)->unsetCVTerms();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_unsetModelHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_unsetModelHistory" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)(arg1)->unsetModelHistory();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getResourceBiologicalQualifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  BiolQualifierType_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_getResourceBiologicalQualifier", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getResourceBiologicalQualifier" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBase_getResourceBiologicalQualifier" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (BiolQualifierType_t)(arg1)->getResourceBiologicalQualifier(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getResourceModelQualifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  ModelQualifierType_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_getResourceModelQualifier", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getResourceModelQualifier" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBase_getResourceModelQualifier" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (ModelQualifierType_t)(arg1)->getResourceModelQualifier(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Model *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getModel" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (Model *)((SBase const *)arg1)->getModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Model, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getLevel" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (unsigned int)((SBase const *)arg1)->getLevel();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getVersion" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (unsigned int)((SBase const *)arg1)->getVersion();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getPackageCoreVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getPackageCoreVersion" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (unsigned int)((SBase const *)arg1)->getPackageCoreVersion();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getPackageVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getPackageVersion" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (unsigned int)((SBase const *)arg1)->getPackageVersion();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getPackageName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getPackageName" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (std::string *) &((SBase const *)arg1)->getPackageName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getTypeCode" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)((SBase const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_hasValidLevelVersionNamespaceCombination(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_hasValidLevelVersionNamespaceCombination" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)(arg1)->hasValidLevelVersionNamespaceCombination();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getElementName" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (std::string *) &((SBase const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_toSBML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_toSBML" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (char *)(arg1)->toSBML();
  resultobj = SWIG_FromCharPtr((const char *)result);
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_toXMLNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_toXMLNode" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (XMLNode *)(arg1)->toXMLNode();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *arg2 = 0 ;
  XMLErrorSeverityOverride_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_read" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLNode,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_read" "', argument " "2"" of type '" "XMLNode &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_read" "', argument " "2"" of type '" "XMLNode &""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBase_read" "', argument " "3"" of type '" "XMLErrorSeverityOverride_t""'");
  } 
  arg3 = static_cast< XMLErrorSeverityOverride_t >(val3);
  try {
    (arg1)->read(*arg2,arg3);
  } catch(SBMLConstructorException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new SBMLConstructorException(static_cast< const SBMLConstructorException& >(_e))),SWIGTYPE_p_SBMLConstructorException,SWIG_POINTER_OWN), "SBMLConstructorException", SWIGTYPE_p_SBMLConstructorException); SWIG_fail;
  } catch(SBMLExtensionException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new SBMLExtensionException(static_cast< const SBMLExtensionException& >(_e))),SWIGTYPE_p_SBMLExtensionException,SWIG_POINTER_OWN), "SBMLExtensionException", SWIGTYPE_p_SBMLExtensionException); SWIG_fail;
  } catch(XMLConstructorException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new XMLConstructorException(static_cast< const XMLConstructorException& >(_e))),SWIGTYPE_p_XMLConstructorException,SWIG_POINTER_OWN), "XMLConstructorException", SWIGTYPE_p_XMLConstructorException); SWIG_fail;
  } catch(...) {
    SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  XMLNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_read" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLNode,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_read" "', argument " "2"" of type '" "XMLNode &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_read" "', argument " "2"" of type '" "XMLNode &""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  try {
    (arg1)->read(*arg2);
  } catch(SBMLConstructorException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new SBMLConstructorException(static_cast< const SBMLConstructorException& >(_e))),SWIGTYPE_p_SBMLConstructorException,SWIG_POINTER_OWN), "SBMLConstructorException", SWIGTYPE_p_SBMLConstructorException); SWIG_fail;
  } catch(SBMLExtensionException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new SBMLExtensionException(static_cast< const SBMLExtensionException& >(_e))),SWIGTYPE_p_SBMLExtensionException,SWIG_POINTER_OWN), "SBMLExtensionException", SWIGTYPE_p_SBMLExtensionException); SWIG_fail;
  } catch(XMLConstructorException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new XMLConstructorException(static_cast< const XMLConstructorException& >(_e))),SWIGTYPE_p_XMLConstructorException,SWIG_POINTER_OWN), "XMLConstructorException", SWIGTYPE_p_XMLConstructorException); SWIG_fail;
  } catch(...) {
    SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getPlugin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getPlugin" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_getPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_getPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBasePlugin *)(arg1)->getPlugin((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getPlugin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getPlugin" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_getPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_getPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBasePlugin *)((SBase const *)arg1)->getPlugin((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getPlugin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getPlugin" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBase_getPlugin" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBasePlugin *)(arg1)->getPlugin(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getPlugin__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getPlugin" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBase_getPlugin" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBasePlugin *)((SBase const *)arg1)->getPlugin(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getPlugin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getPlugin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBase_getPlugin__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBase_getPlugin__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_getPlugin__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_getPlugin__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getPlugin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getPlugin(std::string const &)\n"
    "    SBase::getPlugin(std::string const &) const\n"
    "    SBase::getPlugin(unsigned int)\n"
    "    SBase::getPlugin(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getDisabledPlugin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getDisabledPlugin" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBase_getDisabledPlugin" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBasePlugin *)(arg1)->getDisabledPlugin(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getDisabledPlugin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getDisabledPlugin" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBase_getDisabledPlugin" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBasePlugin *)((SBase const *)arg1)->getDisabledPlugin(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getDisabledPlugin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getDisabledPlugin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBase_getDisabledPlugin__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBase_getDisabledPlugin__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getDisabledPlugin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getDisabledPlugin(unsigned int)\n"
    "    SBase::getDisabledPlugin(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getNumPlugins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getNumPlugins" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (unsigned int)((SBase const *)arg1)->getNumPlugins();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getNumDisabledPlugins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getNumDisabledPlugins" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (unsigned int)((SBase const *)arg1)->getNumDisabledPlugins();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_deleteDisabledPlugins__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_deleteDisabledPlugins" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBase_deleteDisabledPlugins" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->deleteDisabledPlugins(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_deleteDisabledPlugins__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_deleteDisabledPlugins" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  (arg1)->deleteDisabledPlugins();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_deleteDisabledPlugins(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_deleteDisabledPlugins", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_deleteDisabledPlugins__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBase_deleteDisabledPlugins__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_deleteDisabledPlugins'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::deleteDisabledPlugins(bool)\n"
    "    SBase::deleteDisabledPlugins()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_enablePackage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_enablePackage", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_enablePackage" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_enablePackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_enablePackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBase_enablePackage" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_enablePackage" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBase_enablePackage" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (int)(arg1)->enablePackage((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_disablePackage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_disablePackage", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_disablePackage" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_disablePackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_disablePackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBase_disablePackage" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_disablePackage" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (int)(arg1)->disablePackage((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_enablePackageInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_enablePackageInternal", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_enablePackageInternal" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBase_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBase_enablePackageInternal" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->enablePackageInternal((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_isPackageURIEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_isPackageURIEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isPackageURIEnabled" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_isPackageURIEnabled" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_isPackageURIEnabled" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((SBase const *)arg1)->isPackageURIEnabled((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_isPackageEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_isPackageEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isPackageEnabled" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_isPackageEnabled" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_isPackageEnabled" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((SBase const *)arg1)->isPackageEnabled((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_isPkgURIEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_isPkgURIEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isPkgURIEnabled" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_isPkgURIEnabled" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_isPkgURIEnabled" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((SBase const *)arg1)->isPkgURIEnabled((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_isPkgEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_isPkgEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isPkgEnabled" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_isPkgEnabled" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_isPkgEnabled" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((SBase const *)arg1)->isPkgEnabled((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_writeExtensionElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  XMLOutputStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_writeExtensionElements", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_writeExtensionElements" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLOutputStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_writeExtensionElements" "', argument " "2"" of type '" "XMLOutputStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_writeExtensionElements" "', argument " "2"" of type '" "XMLOutputStream &""'"); 
  }
  arg2 = reinterpret_cast< XMLOutputStream * >(argp2);
  ((SBase const *)arg1)->writeExtensionElements(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_read__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  XMLInputStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_read" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLInputStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_read" "', argument " "2"" of type '" "XMLInputStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_read" "', argument " "2"" of type '" "XMLInputStream &""'"); 
  }
  arg2 = reinterpret_cast< XMLInputStream * >(argp2);
  try {
    (arg1)->read(*arg2);
  } catch(SBMLConstructorException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new SBMLConstructorException(static_cast< const SBMLConstructorException& >(_e))),SWIGTYPE_p_SBMLConstructorException,SWIG_POINTER_OWN), "SBMLConstructorException", SWIGTYPE_p_SBMLConstructorException); SWIG_fail;
  } catch(SBMLExtensionException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new SBMLExtensionException(static_cast< const SBMLExtensionException& >(_e))),SWIGTYPE_p_SBMLExtensionException,SWIG_POINTER_OWN), "SBMLExtensionException", SWIGTYPE_p_SBMLExtensionException); SWIG_fail;
  } catch(XMLConstructorException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new XMLConstructorException(static_cast< const XMLConstructorException& >(_e))),SWIGTYPE_p_XMLConstructorException,SWIG_POINTER_OWN), "XMLConstructorException", SWIGTYPE_p_XMLConstructorException); SWIG_fail;
  } catch(...) {
    SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_read(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_read", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNode, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_read__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLInputStream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_read__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNode, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBase_read__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_read'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::read(XMLNode &,XMLErrorSeverityOverride_t)\n"
    "    SBase::read(XMLNode &)\n"
    "    SBase::read(XMLInputStream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  XMLOutputStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_write", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_write" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLOutputStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_write" "', argument " "2"" of type '" "XMLOutputStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_write" "', argument " "2"" of type '" "XMLOutputStream &""'"); 
  }
  arg2 = reinterpret_cast< XMLOutputStream * >(argp2);
  try {
    ((SBase const *)arg1)->write(*arg2);
  } catch(SBMLConstructorException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new SBMLConstructorException(static_cast< const SBMLConstructorException& >(_e))),SWIGTYPE_p_SBMLConstructorException,SWIG_POINTER_OWN), "SBMLConstructorException", SWIGTYPE_p_SBMLConstructorException); SWIG_fail;
  } catch(SBMLExtensionException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new SBMLExtensionException(static_cast< const SBMLExtensionException& >(_e))),SWIGTYPE_p_SBMLExtensionException,SWIG_POINTER_OWN), "SBMLExtensionException", SWIGTYPE_p_SBMLExtensionException); SWIG_fail;
  } catch(XMLConstructorException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new XMLConstructorException(static_cast< const XMLConstructorException& >(_e))),SWIGTYPE_p_XMLConstructorException,SWIG_POINTER_OWN), "XMLConstructorException", SWIGTYPE_p_XMLConstructorException); SWIG_fail;
  } catch(...) {
    SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_hasRequiredAttributes" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)((SBase const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_hasRequiredElements" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)((SBase const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_checkCompatibility(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_checkCompatibility", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_checkCompatibility" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_checkCompatibility" "', argument " "2"" of type '" "SBase const *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  result = (int)((SBase const *)arg1)->checkCompatibility((SBase const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_setSBMLNamespacesAndOwn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_setSBMLNamespacesAndOwn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_setSBMLNamespacesAndOwn" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_SBMLNamespaces, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_setSBMLNamespacesAndOwn" "', argument " "2"" of type '" "SBMLNamespaces *""'");
  }
  (arg1)->setSBMLNamespacesAndOwn(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getSBMLNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLNamespaces *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getSBMLNamespaces" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (SBMLNamespaces *)((SBase const *)arg1)->getSBMLNamespaces();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_removeDuplicateAnnotations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_removeDuplicateAnnotations" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  (arg1)->removeDuplicateAnnotations();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_checkMathMLNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  XMLToken arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_checkMathMLNamespace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_checkMathMLNamespace" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLToken,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_checkMathMLNamespace" "', argument " "2"" of type '" "XMLToken const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_checkMathMLNamespace" "', argument " "2"" of type '" "XMLToken const""'");
    } else {
      XMLToken * temp = reinterpret_cast< XMLToken * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (arg1)->checkMathMLNamespace(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getDerivedUnitDefinition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  UnitDefinition *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getDerivedUnitDefinition" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_containsUndeclaredUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_containsUndeclaredUnits" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)(arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_removeFromParentAndDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_removeFromParentAndDelete" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)(arg1)->removeFromParentAndDelete();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_matchesSBMLNamespaces__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_matchesSBMLNamespaces" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_matchesSBMLNamespaces" "', argument " "2"" of type '" "SBase const *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  result = (bool)(arg1)->matchesSBMLNamespaces((SBase const *)arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_matchesSBMLNamespaces__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_matchesSBMLNamespaces" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_matchesSBMLNamespaces" "', argument " "2"" of type '" "SBase const *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  result = (bool)((SBase const *)arg1)->matchesSBMLNamespaces((SBase const *)arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_matchesSBMLNamespaces(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_matchesSBMLNamespaces", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_matchesSBMLNamespaces__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_matchesSBMLNamespaces__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_matchesSBMLNamespaces'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::matchesSBMLNamespaces(SBase const *)\n"
    "    SBase::matchesSBMLNamespaces(SBase const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_matchesRequiredSBMLNamespacesForAddition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_matchesRequiredSBMLNamespacesForAddition" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_matchesRequiredSBMLNamespacesForAddition" "', argument " "2"" of type '" "SBase const *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  result = (bool)(arg1)->matchesRequiredSBMLNamespacesForAddition((SBase const *)arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_matchesRequiredSBMLNamespacesForAddition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_matchesRequiredSBMLNamespacesForAddition" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_matchesRequiredSBMLNamespacesForAddition" "', argument " "2"" of type '" "SBase const *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  result = (bool)((SBase const *)arg1)->matchesRequiredSBMLNamespacesForAddition((SBase const *)arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_matchesRequiredSBMLNamespacesForAddition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_matchesRequiredSBMLNamespacesForAddition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_matchesRequiredSBMLNamespacesForAddition__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_matchesRequiredSBMLNamespacesForAddition__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_matchesRequiredSBMLNamespacesForAddition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::matchesRequiredSBMLNamespacesForAddition(SBase const *)\n"
    "    SBase::matchesRequiredSBMLNamespacesForAddition(SBase const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_isSetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_isSetUserData" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)((SBase const *)arg1)->isSetUserData();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_unsetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_unsetUserData" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (int)(arg1)->unsetUserData();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getURI" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = ((SBase const *)arg1)->getURI();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getPrefix" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = ((SBase const *)arg1)->getPrefix();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_hasOptionalAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_hasOptionalAttributes" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)((SBase const *)arg1)->hasOptionalAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_hasOptionalElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_hasOptionalElements" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (bool)((SBase const *)arg1)->hasOptionalElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_updateSBMLNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBase_updateSBMLNamespace", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_updateSBMLNamespace" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBase_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBase_updateSBMLNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBase_updateSBMLNamespace" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  (arg1)->updateSBMLNamespace((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getListOfAllElements__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  ElementFilter *arg2 = (ElementFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ListWrapper< SBase > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getListOfAllElements" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ElementFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_getListOfAllElements" "', argument " "2"" of type '" "ElementFilter *""'"); 
  }
  arg2 = reinterpret_cast< ElementFilter * >(argp2);
  result = SBase_getListOfAllElements__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new ListWrapper< SBase >(static_cast< const ListWrapper< SBase >& >(result))), SWIGTYPE_p_ListWrapperT_SBase_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getListOfAllElements__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListWrapper< SBase > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getListOfAllElements" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = SBase_getListOfAllElements__SWIG_0(arg1);
  resultobj = SWIG_NewPointerObj((new ListWrapper< SBase >(static_cast< const ListWrapper< SBase >& >(result))), SWIGTYPE_p_ListWrapperT_SBase_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getListOfAllElements(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getListOfAllElements", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getListOfAllElements__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ElementFilter, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_getListOfAllElements__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getListOfAllElements'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getListOfAllElements(ElementFilter *)\n"
    "    SBase::getListOfAllElements()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBase_getListOfAllElementsFromPlugins__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  ElementFilter *arg2 = (ElementFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ListWrapper< SBase > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getListOfAllElementsFromPlugins" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ElementFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBase_getListOfAllElementsFromPlugins" "', argument " "2"" of type '" "ElementFilter *""'"); 
  }
  arg2 = reinterpret_cast< ElementFilter * >(argp2);
  result = SBase_getListOfAllElementsFromPlugins__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new ListWrapper< SBase >(static_cast< const ListWrapper< SBase >& >(result))), SWIGTYPE_p_ListWrapperT_SBase_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getListOfAllElementsFromPlugins__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListWrapper< SBase > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBase_getListOfAllElementsFromPlugins" "', argument " "1"" of type '" "SBase *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = SBase_getListOfAllElementsFromPlugins__SWIG_0(arg1);
  resultobj = SWIG_NewPointerObj((new ListWrapper< SBase >(static_cast< const ListWrapper< SBase >& >(result))), SWIGTYPE_p_ListWrapperT_SBase_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBase_getListOfAllElementsFromPlugins(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBase_getListOfAllElementsFromPlugins", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBase_getListOfAllElementsFromPlugins__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ElementFilter, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBase_getListOfAllElementsFromPlugins__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBase_getListOfAllElementsFromPlugins'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBase::getListOfAllElementsFromPlugins(ElementFilter *)\n"
    "    SBase::getListOfAllElementsFromPlugins()\n");
  return 0;
}


SWIGINTERN PyObject *SBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBase, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ListOf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOf *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOf" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOf" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOf *)new ListOf(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  ListOf *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOf" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = (ListOf *)new ListOf(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ListOf *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (ListOf *)new ListOf();
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOf__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOf *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOf" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOf *)new ListOf(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOf" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOf__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOf *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOf *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ListOf,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOf" "', argument " "1"" of type '" "ListOf const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListOf" "', argument " "1"" of type '" "ListOf const &""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  {
    try {
      result = (ListOf *)new ListOf((ListOf const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOf", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ListOf__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOf__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ListOf, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOf__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ListOf__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOf__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOf::ListOf(unsigned int,unsigned int)\n"
    "    ListOf::ListOf(unsigned int)\n"
    "    ListOf::ListOf()\n"
    "    ListOf::ListOf(SBMLNamespaces *)\n"
    "    ListOf::ListOf(ListOf const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOf_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOf *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_clone" "', argument " "1"" of type '" "ListOf const *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  result = (ListOf *)((ListOf const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOf, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOf_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_append" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOf_append" "', argument " "2"" of type '" "SBase const *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  result = (int)(arg1)->append((SBase const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_appendAndOwn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOf_appendAndOwn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_appendAndOwn" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_SBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOf_appendAndOwn" "', argument " "2"" of type '" "SBase *""'");
  }
  result = (int)(arg1)->appendAndOwn(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_appendFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  ListOf *arg2 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOf_appendFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_appendFrom" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOf_appendFrom" "', argument " "2"" of type '" "ListOf const *""'"); 
  }
  arg2 = reinterpret_cast< ListOf * >(argp2);
  result = (int)(arg1)->appendFrom((ListOf const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  int arg2 ;
  SBase *arg3 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOf_insert", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_insert" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOf_insert" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ListOf_insert" "', argument " "3"" of type '" "SBase const *""'"); 
  }
  arg3 = reinterpret_cast< SBase * >(argp3);
  result = (int)(arg1)->insert(arg2,(SBase const *)arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_insertAndOwn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  int arg2 ;
  SBase *arg3 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOf_insertAndOwn", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_insertAndOwn" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOf_insertAndOwn" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_SBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ListOf_insertAndOwn" "', argument " "3"" of type '" "SBase *""'");
  }
  result = (int)(arg1)->insertAndOwn(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SBase *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_get" "', argument " "1"" of type '" "ListOf const *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOf_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBase *)((ListOf const *)arg1)->get(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SBase *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_get" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOf_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBase *)(arg1)->get(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOf_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOf_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOf_get__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOf_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOf::get(unsigned int) const\n"
    "    ListOf::get(unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOf_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOf_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_getElementBySId" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOf_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOf_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_getElementByMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOf_getElementByMetaId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_getElementByMetaId" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOf_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOf_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementByMetaId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_clear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_clear" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOf_clear" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->clear(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_clear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_clear" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_clear(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOf_clear", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ListOf_clear__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOf_clear__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOf_clear'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOf::clear(bool)\n"
    "    ListOf::clear()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOf_removeFromParentAndDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_removeFromParentAndDelete" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  result = (int)(arg1)->removeFromParentAndDelete();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOf_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_remove" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOf_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBase *)(arg1)->remove(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_size" "', argument " "1"" of type '" "ListOf const *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  result = (unsigned int)((ListOf const *)arg1)->size();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_connectToChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_connectToChild" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  (arg1)->connectToChild();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_getTypeCode" "', argument " "1"" of type '" "ListOf const *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  result = (int)((ListOf const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_getItemTypeCode" "', argument " "1"" of type '" "ListOf const *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  result = (int)((ListOf const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_getElementName" "', argument " "1"" of type '" "ListOf const *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  result = (std::string *) &((ListOf const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_enablePackageInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOf_enablePackageInternal", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_enablePackageInternal" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOf_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOf_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ListOf_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOf_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListOf_enablePackageInternal" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->enablePackageInternal((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_updateSBMLNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOf_updateSBMLNamespace", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_updateSBMLNamespace" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOf_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOf_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ListOf_updateSBMLNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ListOf_updateSBMLNamespace" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  (arg1)->updateSBMLNamespace((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_hasOptionalElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_hasOptionalElements" "', argument " "1"" of type '" "ListOf const *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  result = (bool)((ListOf const *)arg1)->hasOptionalElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_isExplicitlyListed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_isExplicitlyListed" "', argument " "1"" of type '" "ListOf const *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  result = (bool)((ListOf const *)arg1)->isExplicitlyListed();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_setExplicitlyListed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_setExplicitlyListed" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOf_setExplicitlyListed" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setExplicitlyListed(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_setExplicitlyListed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_setExplicitlyListed" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  (arg1)->setExplicitlyListed();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf_setExplicitlyListed(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOf_setExplicitlyListed", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ListOf_setExplicitlyListed__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOf, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOf_setExplicitlyListed__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOf_setExplicitlyListed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOf::setExplicitlyListed(bool)\n"
    "    ListOf::setExplicitlyListed()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOf_sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf_sort" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  (arg1)->sort();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOf___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOf *arg1 = (ListOf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOf___len__" "', argument " "1"" of type '" "ListOf *""'"); 
  }
  arg1 = reinterpret_cast< ListOf * >(argp1);
  result = (int)ListOf___len__(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOf, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOf_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Model__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Model *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Model" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Model" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Model *)new Model(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Model, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Model__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Model *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Model" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (Model *)new Model(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Model, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Model(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Model" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Model__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Model *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Model,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Model" "', argument " "1"" of type '" "Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Model" "', argument " "1"" of type '" "Model const &""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    try {
      result = (Model *)new Model((Model const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Model, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Model(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Model", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Model__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Model, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Model__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Model__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Model'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::Model(unsigned int,unsigned int)\n"
    "    Model::Model(SBMLNamespaces *)\n"
    "    Model::Model(Model const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Model *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_clone" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (Model *)((Model const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Model, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getElementBySId" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getElementByMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_getElementByMetaId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getElementByMetaId" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementByMetaId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getId" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (std::string *) &((Model const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getName" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (std::string *) &((Model const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getSubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getSubstanceUnits" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (std::string *) &((Model const *)arg1)->getSubstanceUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getTimeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getTimeUnits" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (std::string *) &((Model const *)arg1)->getTimeUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getVolumeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getVolumeUnits" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (std::string *) &((Model const *)arg1)->getVolumeUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getAreaUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getAreaUnits" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (std::string *) &((Model const *)arg1)->getAreaUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getLengthUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getLengthUnits" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (std::string *) &((Model const *)arg1)->getLengthUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getExtentUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getExtentUnits" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (std::string *) &((Model const *)arg1)->getExtentUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getConversionFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getConversionFactor" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (std::string *) &((Model const *)arg1)->getConversionFactor();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isSetId" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)((Model const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isSetName" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)((Model const *)arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_isSetSubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isSetSubstanceUnits" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)((Model const *)arg1)->isSetSubstanceUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_isSetTimeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isSetTimeUnits" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)((Model const *)arg1)->isSetTimeUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_isSetVolumeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isSetVolumeUnits" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)((Model const *)arg1)->isSetVolumeUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_isSetAreaUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isSetAreaUnits" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)((Model const *)arg1)->isSetAreaUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_isSetLengthUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isSetLengthUnits" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)((Model const *)arg1)->isSetLengthUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_isSetExtentUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isSetExtentUnits" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)((Model const *)arg1)->isSetExtentUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_isSetConversionFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isSetConversionFactor" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)((Model const *)arg1)->isSetConversionFactor();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setId" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setName" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setSubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_setSubstanceUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setSubstanceUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_setSubstanceUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_setSubstanceUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setSubstanceUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setTimeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_setTimeUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setTimeUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_setTimeUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_setTimeUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setTimeUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setVolumeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_setVolumeUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setVolumeUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_setVolumeUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_setVolumeUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setVolumeUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setAreaUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_setAreaUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setAreaUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_setAreaUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_setAreaUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setAreaUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setLengthUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_setLengthUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setLengthUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_setLengthUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_setLengthUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setLengthUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setExtentUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_setExtentUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setExtentUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_setExtentUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_setExtentUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setExtentUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setConversionFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_setConversionFactor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setConversionFactor" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_setConversionFactor" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_setConversionFactor" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setConversionFactor((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_unsetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_unsetId" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (int)(arg1)->unsetId();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_unsetName" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_unsetSubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_unsetSubstanceUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (int)(arg1)->unsetSubstanceUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_unsetTimeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_unsetTimeUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (int)(arg1)->unsetTimeUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_unsetVolumeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_unsetVolumeUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (int)(arg1)->unsetVolumeUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_unsetAreaUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_unsetAreaUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (int)(arg1)->unsetAreaUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_unsetLengthUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_unsetLengthUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (int)(arg1)->unsetLengthUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_unsetExtentUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_unsetExtentUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (int)(arg1)->unsetExtentUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_unsetConversionFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_unsetConversionFactor" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (int)(arg1)->unsetConversionFactor();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addFunctionDefinition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  FunctionDefinition *arg2 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_addFunctionDefinition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addFunctionDefinition" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addFunctionDefinition" "', argument " "2"" of type '" "FunctionDefinition const *""'"); 
  }
  arg2 = reinterpret_cast< FunctionDefinition * >(argp2);
  result = (int)(arg1)->addFunctionDefinition((FunctionDefinition const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addUnitDefinition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  UnitDefinition *arg2 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_addUnitDefinition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addUnitDefinition" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addUnitDefinition" "', argument " "2"" of type '" "UnitDefinition const *""'"); 
  }
  arg2 = reinterpret_cast< UnitDefinition * >(argp2);
  result = (int)(arg1)->addUnitDefinition((UnitDefinition const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addCompartmentType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  CompartmentType *arg2 = (CompartmentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_addCompartmentType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addCompartmentType" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addCompartmentType" "', argument " "2"" of type '" "CompartmentType const *""'"); 
  }
  arg2 = reinterpret_cast< CompartmentType * >(argp2);
  result = (int)(arg1)->addCompartmentType((CompartmentType const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addSpeciesType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  SpeciesType *arg2 = (SpeciesType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_addSpeciesType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addSpeciesType" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addSpeciesType" "', argument " "2"" of type '" "SpeciesType const *""'"); 
  }
  arg2 = reinterpret_cast< SpeciesType * >(argp2);
  result = (int)(arg1)->addSpeciesType((SpeciesType const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addCompartment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  Compartment *arg2 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_addCompartment", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addCompartment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addCompartment" "', argument " "2"" of type '" "Compartment const *""'"); 
  }
  arg2 = reinterpret_cast< Compartment * >(argp2);
  result = (int)(arg1)->addCompartment((Compartment const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addSpecies(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  Species *arg2 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_addSpecies", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addSpecies" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addSpecies" "', argument " "2"" of type '" "Species const *""'"); 
  }
  arg2 = reinterpret_cast< Species * >(argp2);
  result = (int)(arg1)->addSpecies((Species const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  Parameter *arg2 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_addParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addParameter" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addParameter" "', argument " "2"" of type '" "Parameter const *""'"); 
  }
  arg2 = reinterpret_cast< Parameter * >(argp2);
  result = (int)(arg1)->addParameter((Parameter const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addInitialAssignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  InitialAssignment *arg2 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_addInitialAssignment", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addInitialAssignment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addInitialAssignment" "', argument " "2"" of type '" "InitialAssignment const *""'"); 
  }
  arg2 = reinterpret_cast< InitialAssignment * >(argp2);
  result = (int)(arg1)->addInitialAssignment((InitialAssignment const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  Rule *arg2 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_addRule", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addRule" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addRule" "', argument " "2"" of type '" "Rule const *""'"); 
  }
  arg2 = reinterpret_cast< Rule * >(argp2);
  result = (int)(arg1)->addRule((Rule const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  Constraint *arg2 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_addConstraint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addConstraint" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addConstraint" "', argument " "2"" of type '" "Constraint const *""'"); 
  }
  arg2 = reinterpret_cast< Constraint * >(argp2);
  result = (int)(arg1)->addConstraint((Constraint const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addReaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  Reaction *arg2 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_addReaction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addReaction" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addReaction" "', argument " "2"" of type '" "Reaction const *""'"); 
  }
  arg2 = reinterpret_cast< Reaction * >(argp2);
  result = (int)(arg1)->addReaction((Reaction const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  Event *arg2 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_addEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addEvent" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addEvent" "', argument " "2"" of type '" "Event const *""'"); 
  }
  arg2 = reinterpret_cast< Event * >(argp2);
  result = (int)(arg1)->addEvent((Event const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createFunctionDefinition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FunctionDefinition *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createFunctionDefinition" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (FunctionDefinition *)(arg1)->createFunctionDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createUnitDefinition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  UnitDefinition *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createUnitDefinition" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (UnitDefinition *)(arg1)->createUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Unit *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createUnit" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (Unit *)(arg1)->createUnit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Unit, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createCompartmentType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompartmentType *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createCompartmentType" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (CompartmentType *)(arg1)->createCompartmentType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createSpeciesType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SpeciesType *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createSpeciesType" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (SpeciesType *)(arg1)->createSpeciesType();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createCompartment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Compartment *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createCompartment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (Compartment *)(arg1)->createCompartment();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createSpecies(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Species *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createSpecies" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (Species *)(arg1)->createSpecies();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Parameter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createParameter" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (Parameter *)(arg1)->createParameter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createInitialAssignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  InitialAssignment *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createInitialAssignment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (InitialAssignment *)(arg1)->createInitialAssignment();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createAlgebraicRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AlgebraicRule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createAlgebraicRule" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (AlgebraicRule *)(arg1)->createAlgebraicRule();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AlgebraicRule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createAssignmentRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AssignmentRule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createAssignmentRule" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (AssignmentRule *)(arg1)->createAssignmentRule();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AssignmentRule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createRateRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  RateRule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createRateRule" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (RateRule *)(arg1)->createRateRule();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RateRule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Constraint *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createConstraint" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (Constraint *)(arg1)->createConstraint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Constraint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createReaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Reaction *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createReaction" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (Reaction *)(arg1)->createReaction();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createReactant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SpeciesReference *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createReactant" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (SpeciesReference *)(arg1)->createReactant();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SpeciesReference *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createProduct" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (SpeciesReference *)(arg1)->createProduct();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createModifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ModifierSpeciesReference *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createModifier" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ModifierSpeciesReference *)(arg1)->createModifier();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createKineticLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  KineticLaw *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createKineticLaw" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (KineticLaw *)(arg1)->createKineticLaw();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KineticLaw, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createKineticLawParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Parameter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createKineticLawParameter" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (Parameter *)(arg1)->createKineticLawParameter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createKineticLawLocalParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  LocalParameter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createKineticLawLocalParameter" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (LocalParameter *)(arg1)->createKineticLawLocalParameter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Event *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createEvent" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (Event *)(arg1)->createEvent();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createEventAssignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  EventAssignment *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createEventAssignment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (EventAssignment *)(arg1)->createEventAssignment();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createTrigger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Trigger *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createTrigger" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (Trigger *)(arg1)->createTrigger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Trigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_createDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Delay *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_createDelay" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (Delay *)(arg1)->createDelay();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Delay, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setAnnotation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setAnnotation" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_setAnnotation" "', argument " "2"" of type '" "XMLNode const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  result = (int)(arg1)->setAnnotation((XMLNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setAnnotation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setAnnotation" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_setAnnotation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_setAnnotation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setAnnotation((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setAnnotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_setAnnotation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_setAnnotation__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_setAnnotation__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_setAnnotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::setAnnotation(XMLNode const *)\n"
    "    Model::setAnnotation(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_appendAnnotation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_appendAnnotation" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_appendAnnotation" "', argument " "2"" of type '" "XMLNode const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  result = (int)(arg1)->appendAnnotation((XMLNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_appendAnnotation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_appendAnnotation" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_appendAnnotation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_appendAnnotation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->appendAnnotation((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_appendAnnotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_appendAnnotation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_appendAnnotation__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_appendAnnotation__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_appendAnnotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::appendAnnotation(XMLNode const *)\n"
    "    Model::appendAnnotation(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getListOfFunctionDefinitions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfFunctionDefinitions *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfFunctionDefinitions" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfFunctionDefinitions *)((Model const *)arg1)->getListOfFunctionDefinitions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfFunctionDefinitions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfFunctionDefinitions *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfFunctionDefinitions" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfFunctionDefinitions *)(arg1)->getListOfFunctionDefinitions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfFunctionDefinitions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getListOfFunctionDefinitions", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfFunctionDefinitions__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfFunctionDefinitions__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getListOfFunctionDefinitions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getListOfFunctionDefinitions() const\n"
    "    Model::getListOfFunctionDefinitions()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getListOfUnitDefinitions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfUnitDefinitions *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfUnitDefinitions" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfUnitDefinitions *)((Model const *)arg1)->getListOfUnitDefinitions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfUnitDefinitions, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfUnitDefinitions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfUnitDefinitions *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfUnitDefinitions" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfUnitDefinitions *)(arg1)->getListOfUnitDefinitions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfUnitDefinitions, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfUnitDefinitions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getListOfUnitDefinitions", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfUnitDefinitions__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfUnitDefinitions__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getListOfUnitDefinitions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getListOfUnitDefinitions() const\n"
    "    Model::getListOfUnitDefinitions()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getListOfCompartmentTypes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfCompartmentTypes *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfCompartmentTypes" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfCompartmentTypes *)((Model const *)arg1)->getListOfCompartmentTypes();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfCompartmentTypes, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfCompartmentTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfCompartmentTypes *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfCompartmentTypes" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfCompartmentTypes *)(arg1)->getListOfCompartmentTypes();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfCompartmentTypes, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfCompartmentTypes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getListOfCompartmentTypes", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfCompartmentTypes__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfCompartmentTypes__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getListOfCompartmentTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getListOfCompartmentTypes() const\n"
    "    Model::getListOfCompartmentTypes()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getListOfSpeciesTypes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpeciesTypes *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfSpeciesTypes" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfSpeciesTypes *)((Model const *)arg1)->getListOfSpeciesTypes();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesTypes, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfSpeciesTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpeciesTypes *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfSpeciesTypes" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfSpeciesTypes *)(arg1)->getListOfSpeciesTypes();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesTypes, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfSpeciesTypes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getListOfSpeciesTypes", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfSpeciesTypes__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfSpeciesTypes__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getListOfSpeciesTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getListOfSpeciesTypes() const\n"
    "    Model::getListOfSpeciesTypes()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getListOfCompartments__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfCompartments *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfCompartments" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfCompartments *)((Model const *)arg1)->getListOfCompartments();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfCompartments, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfCompartments__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfCompartments *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfCompartments" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfCompartments *)(arg1)->getListOfCompartments();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfCompartments, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfCompartments(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getListOfCompartments", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfCompartments__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfCompartments__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getListOfCompartments'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getListOfCompartments() const\n"
    "    Model::getListOfCompartments()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getListOfSpecies__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpecies *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfSpecies" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfSpecies *)((Model const *)arg1)->getListOfSpecies();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpecies, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfSpecies__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpecies *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfSpecies" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfSpecies *)(arg1)->getListOfSpecies();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpecies, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfSpecies(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getListOfSpecies", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfSpecies__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfSpecies__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getListOfSpecies'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getListOfSpecies() const\n"
    "    Model::getListOfSpecies()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getListOfParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfParameters *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfParameters" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfParameters *)((Model const *)arg1)->getListOfParameters();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfParameters, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfParameters *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfParameters" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfParameters *)(arg1)->getListOfParameters();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfParameters, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfParameters(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getListOfParameters", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfParameters__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfParameters__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getListOfParameters'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getListOfParameters() const\n"
    "    Model::getListOfParameters()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getListOfInitialAssignments__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfInitialAssignments *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfInitialAssignments" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfInitialAssignments *)((Model const *)arg1)->getListOfInitialAssignments();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfInitialAssignments, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfInitialAssignments__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfInitialAssignments *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfInitialAssignments" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfInitialAssignments *)(arg1)->getListOfInitialAssignments();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfInitialAssignments, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfInitialAssignments(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getListOfInitialAssignments", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfInitialAssignments__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfInitialAssignments__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getListOfInitialAssignments'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getListOfInitialAssignments() const\n"
    "    Model::getListOfInitialAssignments()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getListOfRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfRules *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfRules" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfRules *)((Model const *)arg1)->getListOfRules();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfRules, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfRules *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfRules" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfRules *)(arg1)->getListOfRules();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfRules, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfRules(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getListOfRules", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfRules__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfRules__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getListOfRules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getListOfRules() const\n"
    "    Model::getListOfRules()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getListOfConstraints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfConstraints *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfConstraints" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfConstraints *)((Model const *)arg1)->getListOfConstraints();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfConstraints, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfConstraints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfConstraints *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfConstraints" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfConstraints *)(arg1)->getListOfConstraints();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfConstraints, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfConstraints(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getListOfConstraints", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfConstraints__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfConstraints__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getListOfConstraints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getListOfConstraints() const\n"
    "    Model::getListOfConstraints()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getListOfReactions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfReactions *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfReactions" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfReactions *)((Model const *)arg1)->getListOfReactions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfReactions, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfReactions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfReactions *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfReactions" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfReactions *)(arg1)->getListOfReactions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfReactions, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfReactions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getListOfReactions", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfReactions__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfReactions__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getListOfReactions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getListOfReactions() const\n"
    "    Model::getListOfReactions()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getListOfEvents__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfEvents *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfEvents" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfEvents *)((Model const *)arg1)->getListOfEvents();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfEvents, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfEvents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfEvents *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getListOfEvents" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (ListOfEvents *)(arg1)->getListOfEvents();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfEvents, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getListOfEvents(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getListOfEvents", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfEvents__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_getListOfEvents__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getListOfEvents'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getListOfEvents() const\n"
    "    Model::getListOfEvents()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getFunctionDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getFunctionDefinition" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getFunctionDefinition" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (FunctionDefinition *)((Model const *)arg1)->getFunctionDefinition(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getFunctionDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getFunctionDefinition" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getFunctionDefinition" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (FunctionDefinition *)(arg1)->getFunctionDefinition(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getFunctionDefinition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getFunctionDefinition" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getFunctionDefinition" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getFunctionDefinition" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (FunctionDefinition *)((Model const *)arg1)->getFunctionDefinition((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getFunctionDefinition__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getFunctionDefinition" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getFunctionDefinition" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getFunctionDefinition" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (FunctionDefinition *)(arg1)->getFunctionDefinition((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getFunctionDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getFunctionDefinition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getFunctionDefinition__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getFunctionDefinition__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getFunctionDefinition__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getFunctionDefinition__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getFunctionDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getFunctionDefinition(unsigned int) const\n"
    "    Model::getFunctionDefinition(unsigned int)\n"
    "    Model::getFunctionDefinition(std::string const &) const\n"
    "    Model::getFunctionDefinition(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getUnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getUnitDefinition" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getUnitDefinition" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (UnitDefinition *)((Model const *)arg1)->getUnitDefinition(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getUnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getUnitDefinition" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getUnitDefinition" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (UnitDefinition *)(arg1)->getUnitDefinition(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getUnitDefinition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getUnitDefinition" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getUnitDefinition" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getUnitDefinition" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (UnitDefinition *)((Model const *)arg1)->getUnitDefinition((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getUnitDefinition__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getUnitDefinition" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getUnitDefinition" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getUnitDefinition" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (UnitDefinition *)(arg1)->getUnitDefinition((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getUnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getUnitDefinition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getUnitDefinition__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getUnitDefinition__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getUnitDefinition__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getUnitDefinition__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getUnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getUnitDefinition(unsigned int) const\n"
    "    Model::getUnitDefinition(unsigned int)\n"
    "    Model::getUnitDefinition(std::string const &) const\n"
    "    Model::getUnitDefinition(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getCompartmentType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getCompartmentType" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getCompartmentType" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CompartmentType *)((Model const *)arg1)->getCompartmentType(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getCompartmentType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getCompartmentType" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getCompartmentType" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CompartmentType *)(arg1)->getCompartmentType(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getCompartmentType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getCompartmentType" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getCompartmentType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getCompartmentType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (CompartmentType *)((Model const *)arg1)->getCompartmentType((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getCompartmentType__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getCompartmentType" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getCompartmentType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getCompartmentType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (CompartmentType *)(arg1)->getCompartmentType((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getCompartmentType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getCompartmentType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getCompartmentType__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getCompartmentType__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getCompartmentType__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getCompartmentType__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getCompartmentType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getCompartmentType(unsigned int) const\n"
    "    Model::getCompartmentType(unsigned int)\n"
    "    Model::getCompartmentType(std::string const &) const\n"
    "    Model::getCompartmentType(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getSpeciesType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getSpeciesType" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getSpeciesType" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SpeciesType *)((Model const *)arg1)->getSpeciesType(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getSpeciesType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getSpeciesType" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getSpeciesType" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SpeciesType *)(arg1)->getSpeciesType(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getSpeciesType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getSpeciesType" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getSpeciesType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getSpeciesType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesType *)((Model const *)arg1)->getSpeciesType((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getSpeciesType__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getSpeciesType" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getSpeciesType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getSpeciesType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesType *)(arg1)->getSpeciesType((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getSpeciesType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getSpeciesType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getSpeciesType__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getSpeciesType__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getSpeciesType__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getSpeciesType__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getSpeciesType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getSpeciesType(unsigned int) const\n"
    "    Model::getSpeciesType(unsigned int)\n"
    "    Model::getSpeciesType(std::string const &) const\n"
    "    Model::getSpeciesType(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getCompartment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getCompartment" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getCompartment" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Compartment *)((Model const *)arg1)->getCompartment(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getCompartment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getCompartment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getCompartment" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Compartment *)(arg1)->getCompartment(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getCompartment__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getCompartment" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getCompartment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getCompartment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Compartment *)((Model const *)arg1)->getCompartment((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getCompartment__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getCompartment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getCompartment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getCompartment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Compartment *)(arg1)->getCompartment((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getCompartment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getCompartment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getCompartment__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getCompartment__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getCompartment__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getCompartment__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getCompartment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getCompartment(unsigned int) const\n"
    "    Model::getCompartment(unsigned int)\n"
    "    Model::getCompartment(std::string const &) const\n"
    "    Model::getCompartment(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getSpecies__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getSpecies" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getSpecies" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Species *)((Model const *)arg1)->getSpecies(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getSpecies__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getSpecies" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getSpecies" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Species *)(arg1)->getSpecies(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getSpecies__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getSpecies" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getSpecies" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getSpecies" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Species *)((Model const *)arg1)->getSpecies((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getSpecies__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getSpecies" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getSpecies" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getSpecies" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Species *)(arg1)->getSpecies((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getSpecies(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getSpecies", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getSpecies__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getSpecies__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getSpecies__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getSpecies__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getSpecies'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getSpecies(unsigned int) const\n"
    "    Model::getSpecies(unsigned int)\n"
    "    Model::getSpecies(std::string const &) const\n"
    "    Model::getSpecies(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getParameter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getParameter" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getParameter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Parameter *)((Model const *)arg1)->getParameter(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getParameter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getParameter" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getParameter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Parameter *)(arg1)->getParameter(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getParameter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getParameter" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Parameter *)((Model const *)arg1)->getParameter((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getParameter__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getParameter" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Parameter *)(arg1)->getParameter((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getParameter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getParameter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getParameter__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getParameter__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getParameter__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getParameter__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getParameter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getParameter(unsigned int) const\n"
    "    Model::getParameter(unsigned int)\n"
    "    Model::getParameter(std::string const &) const\n"
    "    Model::getParameter(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getInitialAssignment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getInitialAssignment" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getInitialAssignment" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (InitialAssignment *)((Model const *)arg1)->getInitialAssignment(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getInitialAssignment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getInitialAssignment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getInitialAssignment" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (InitialAssignment *)(arg1)->getInitialAssignment(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getInitialAssignment__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getInitialAssignment" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getInitialAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getInitialAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (InitialAssignment *)((Model const *)arg1)->getInitialAssignment((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getInitialAssignmentBySymbol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getInitialAssignmentBySymbol" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getInitialAssignmentBySymbol" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getInitialAssignmentBySymbol" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (InitialAssignment *)((Model const *)arg1)->getInitialAssignmentBySymbol((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getInitialAssignment__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getInitialAssignment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getInitialAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getInitialAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (InitialAssignment *)(arg1)->getInitialAssignment((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getInitialAssignment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getInitialAssignment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getInitialAssignment__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getInitialAssignment__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getInitialAssignment__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getInitialAssignment__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getInitialAssignment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getInitialAssignment(unsigned int) const\n"
    "    Model::getInitialAssignment(unsigned int)\n"
    "    Model::getInitialAssignment(std::string const &) const\n"
    "    Model::getInitialAssignment(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getInitialAssignmentBySymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getInitialAssignmentBySymbol" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getInitialAssignmentBySymbol" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getInitialAssignmentBySymbol" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (InitialAssignment *)(arg1)->getInitialAssignmentBySymbol((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getInitialAssignmentBySymbol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getInitialAssignmentBySymbol", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getInitialAssignmentBySymbol__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getInitialAssignmentBySymbol__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getInitialAssignmentBySymbol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getInitialAssignmentBySymbol(std::string const &) const\n"
    "    Model::getInitialAssignmentBySymbol(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getRule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getRule" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getRule" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Rule *)((Model const *)arg1)->getRule(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getRule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getRule" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getRule" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Rule *)(arg1)->getRule(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getRule__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getRule" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Rule *)((Model const *)arg1)->getRule((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getRule__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getRule" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Rule *)(arg1)->getRule((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getRule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getRule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getRule__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getRule__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getRule__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getRule__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getRule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getRule(unsigned int) const\n"
    "    Model::getRule(unsigned int)\n"
    "    Model::getRule(std::string const &) const\n"
    "    Model::getRule(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getRuleByVariable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getRuleByVariable" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Rule *)((Model const *)arg1)->getRuleByVariable((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getRuleByVariable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getRuleByVariable" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Rule *)(arg1)->getRuleByVariable((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getRuleByVariable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getRuleByVariable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getRuleByVariable__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getRuleByVariable__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getRuleByVariable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getRuleByVariable(std::string const &) const\n"
    "    Model::getRuleByVariable(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getAssignmentRule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  AssignmentRule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getAssignmentRule" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getAssignmentRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getAssignmentRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (AssignmentRule *)((Model const *)arg1)->getAssignmentRule((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AssignmentRule, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getAssignmentRule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  AssignmentRule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getAssignmentRule" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getAssignmentRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getAssignmentRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (AssignmentRule *)(arg1)->getAssignmentRule((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AssignmentRule, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getAssignmentRule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getAssignmentRule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getAssignmentRule__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getAssignmentRule__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getAssignmentRule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getAssignmentRule(std::string const &) const\n"
    "    Model::getAssignmentRule(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getRateRule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  RateRule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getRateRule" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getRateRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getRateRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (RateRule *)((Model const *)arg1)->getRateRule((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RateRule, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getRateRule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  RateRule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getRateRule" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getRateRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getRateRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (RateRule *)(arg1)->getRateRule((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RateRule, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getRateRule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getRateRule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getRateRule__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getRateRule__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getRateRule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getRateRule(std::string const &) const\n"
    "    Model::getRateRule(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getAssignmentRuleByVariable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  AssignmentRule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getAssignmentRuleByVariable" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getAssignmentRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getAssignmentRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (AssignmentRule *)((Model const *)arg1)->getAssignmentRuleByVariable((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AssignmentRule, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getAssignmentRuleByVariable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  AssignmentRule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getAssignmentRuleByVariable" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getAssignmentRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getAssignmentRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (AssignmentRule *)(arg1)->getAssignmentRuleByVariable((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AssignmentRule, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getAssignmentRuleByVariable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getAssignmentRuleByVariable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getAssignmentRuleByVariable__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getAssignmentRuleByVariable__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getAssignmentRuleByVariable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getAssignmentRuleByVariable(std::string const &) const\n"
    "    Model::getAssignmentRuleByVariable(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getRateRuleByVariable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  RateRule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getRateRuleByVariable" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getRateRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getRateRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (RateRule *)((Model const *)arg1)->getRateRuleByVariable((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RateRule, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getRateRuleByVariable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  RateRule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getRateRuleByVariable" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getRateRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getRateRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (RateRule *)(arg1)->getRateRuleByVariable((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RateRule, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getRateRuleByVariable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getRateRuleByVariable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getRateRuleByVariable__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getRateRuleByVariable__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getRateRuleByVariable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getRateRuleByVariable(std::string const &) const\n"
    "    Model::getRateRuleByVariable(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getConstraint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Constraint *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getConstraint" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getConstraint" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Constraint *)((Model const *)arg1)->getConstraint(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Constraint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getConstraint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Constraint *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getConstraint" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getConstraint" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Constraint *)(arg1)->getConstraint(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Constraint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getConstraint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getConstraint", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getConstraint__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getConstraint__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getConstraint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getConstraint(unsigned int) const\n"
    "    Model::getConstraint(unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getReaction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getReaction" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getReaction" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Reaction *)((Model const *)arg1)->getReaction(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getReaction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getReaction" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getReaction" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Reaction *)(arg1)->getReaction(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getReaction__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getReaction" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getReaction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getReaction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Reaction *)((Model const *)arg1)->getReaction((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getReaction__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getReaction" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getReaction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getReaction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Reaction *)(arg1)->getReaction((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getReaction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getReaction", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getReaction__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getReaction__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getReaction__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getReaction__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getReaction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getReaction(unsigned int) const\n"
    "    Model::getReaction(unsigned int)\n"
    "    Model::getReaction(std::string const &) const\n"
    "    Model::getReaction(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getSpeciesReference__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getSpeciesReference" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getSpeciesReference" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getSpeciesReference" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesReference *)(arg1)->getSpeciesReference((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getSpeciesReference__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getSpeciesReference" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getSpeciesReference" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getSpeciesReference" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesReference *)((Model const *)arg1)->getSpeciesReference((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getSpeciesReference(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getSpeciesReference", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getSpeciesReference__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getSpeciesReference__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getSpeciesReference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getSpeciesReference(std::string const &)\n"
    "    Model::getSpeciesReference(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getModifierSpeciesReference__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  ModifierSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getModifierSpeciesReference" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getModifierSpeciesReference" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getModifierSpeciesReference" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ModifierSpeciesReference *)(arg1)->getModifierSpeciesReference((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getModifierSpeciesReference__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  ModifierSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getModifierSpeciesReference" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getModifierSpeciesReference" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getModifierSpeciesReference" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ModifierSpeciesReference *)((Model const *)arg1)->getModifierSpeciesReference((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getModifierSpeciesReference(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getModifierSpeciesReference", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getModifierSpeciesReference__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getModifierSpeciesReference__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getModifierSpeciesReference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getModifierSpeciesReference(std::string const &)\n"
    "    Model::getModifierSpeciesReference(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getEvent" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getEvent" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Event *)((Model const *)arg1)->getEvent(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getEvent" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getEvent" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Event *)(arg1)->getEvent(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getEvent__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getEvent" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Event *)((Model const *)arg1)->getEvent((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getEvent__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getEvent" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Event *)(arg1)->getEvent((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_getEvent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getEvent__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getEvent__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getEvent__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_getEvent__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_getEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::getEvent(unsigned int) const\n"
    "    Model::getEvent(unsigned int)\n"
    "    Model::getEvent(std::string const &) const\n"
    "    Model::getEvent(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_getNumFunctionDefinitions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumFunctionDefinitions" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumFunctionDefinitions();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getNumUnitDefinitions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumUnitDefinitions" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumUnitDefinitions();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getNumCompartmentTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumCompartmentTypes" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumCompartmentTypes();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getNumSpeciesTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumSpeciesTypes" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumSpeciesTypes();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getNumCompartments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumCompartments" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumCompartments();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getNumSpecies(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumSpecies" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumSpecies();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getNumSpeciesWithBoundaryCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumSpeciesWithBoundaryCondition" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumSpeciesWithBoundaryCondition();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getNumParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumParameters" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumParameters();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getNumInitialAssignments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumInitialAssignments" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumInitialAssignments();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getNumRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumRules" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumRules();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getNumConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumConstraints" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumConstraints();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getNumReactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumReactions" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumReactions();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getNumEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNumEvents" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (unsigned int)((Model const *)arg1)->getNumEvents();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeFromParentAndDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeFromParentAndDelete" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (int)(arg1)->removeFromParentAndDelete();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_renameAllIds__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  IdentifierTransformer *arg2 = (IdentifierTransformer *) 0 ;
  ElementFilter *arg3 = (ElementFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_renameAllIds" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_IdentifierTransformer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_renameAllIds" "', argument " "2"" of type '" "IdentifierTransformer *""'"); 
  }
  arg2 = reinterpret_cast< IdentifierTransformer * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ElementFilter, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Model_renameAllIds" "', argument " "3"" of type '" "ElementFilter *""'"); 
  }
  arg3 = reinterpret_cast< ElementFilter * >(argp3);
  result = (int)(arg1)->renameAllIds(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_renameAllIds__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  IdentifierTransformer *arg2 = (IdentifierTransformer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_renameAllIds" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_IdentifierTransformer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_renameAllIds" "', argument " "2"" of type '" "IdentifierTransformer *""'"); 
  }
  arg2 = reinterpret_cast< IdentifierTransformer * >(argp2);
  result = (int)(arg1)->renameAllIds(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_renameAllIds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_renameAllIds", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_IdentifierTransformer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_renameAllIds__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_IdentifierTransformer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_ElementFilter, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Model_renameAllIds__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_renameAllIds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::renameAllIds(IdentifierTransformer *,ElementFilter *)\n"
    "    Model::renameAllIds(IdentifierTransformer *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_renameSIdRefs" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Model_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_renameUnitSIdRefs" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Model_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL1ToL2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertL1ToL2" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->convertL1ToL2();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL1ToL3__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertL1ToL3" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_convertL1ToL3" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->convertL1ToL3(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL1ToL3__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertL1ToL3" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->convertL1ToL3();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL1ToL3(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_convertL1ToL3", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_convertL1ToL3__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_convertL1ToL3__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_convertL1ToL3'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::convertL1ToL3(bool)\n"
    "    Model::convertL1ToL3()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_convertL2ToL3__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertL2ToL3" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_convertL2ToL3" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Model_convertL2ToL3" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->convertL2ToL3(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL2ToL3__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertL2ToL3" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_convertL2ToL3" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->convertL2ToL3(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL2ToL3__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertL2ToL3" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->convertL2ToL3();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL2ToL3(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_convertL2ToL3", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_convertL2ToL3__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_convertL2ToL3__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Model_convertL2ToL3__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_convertL2ToL3'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::convertL2ToL3(bool,bool)\n"
    "    Model::convertL2ToL3(bool)\n"
    "    Model::convertL2ToL3()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_convertL2ToL1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertL2ToL1" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_convertL2ToL1" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->convertL2ToL1(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL2ToL1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertL2ToL1" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->convertL2ToL1();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL2ToL1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_convertL2ToL1", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_convertL2ToL1__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_convertL2ToL1__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_convertL2ToL1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::convertL2ToL1(bool)\n"
    "    Model::convertL2ToL1()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_convertL3ToL1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertL3ToL1" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_convertL3ToL1" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->convertL3ToL1(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL3ToL1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertL3ToL1" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->convertL3ToL1();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL3ToL1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_convertL3ToL1", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_convertL3ToL1__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_convertL3ToL1__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_convertL3ToL1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::convertL3ToL1(bool)\n"
    "    Model::convertL3ToL1()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_convertL3ToL2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertL3ToL2" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_convertL3ToL2" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->convertL3ToL2(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL3ToL2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertL3ToL2" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->convertL3ToL2();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertL3ToL2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_convertL3ToL2", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_convertL3ToL2__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_convertL3ToL2__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_convertL3ToL2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::convertL3ToL2(bool)\n"
    "    Model::convertL3ToL2()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_convertFromL3V2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertFromL3V2" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_convertFromL3V2" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->convertFromL3V2(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertFromL3V2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertFromL3V2" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->convertFromL3V2();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertFromL3V2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_convertFromL3V2", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_convertFromL3V2__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_convertFromL3V2__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_convertFromL3V2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::convertFromL3V2(bool)\n"
    "    Model::convertFromL3V2()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_dealWithFast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_dealWithFast" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->dealWithFast();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_dealWithL3Fast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_dealWithL3Fast", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_dealWithL3Fast" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_dealWithL3Fast" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->dealWithL3Fast(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addModifiers" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->addModifiers();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_addConstantAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addConstantAttribute" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->addConstantAttribute();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setSpatialDimensions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setSpatialDimensions" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_setSpatialDimensions" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setSpatialDimensions(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setSpatialDimensions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setSpatialDimensions" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->setSpatialDimensions();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setSpatialDimensions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_setSpatialDimensions", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_setSpatialDimensions__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_setSpatialDimensions__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_setSpatialDimensions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::setSpatialDimensions(double)\n"
    "    Model::setSpatialDimensions()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_addDefinitionsForDefaultUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addDefinitionsForDefaultUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->addDefinitionsForDefaultUnits();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_dealWithDefaultValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_dealWithDefaultValues" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->dealWithDefaultValues();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertParametersToLocals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_convertParametersToLocals", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertParametersToLocals" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_convertParametersToLocals" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Model_convertParametersToLocals" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  (arg1)->convertParametersToLocals(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_setSpeciesReferenceConstantValueAndStoichiometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setSpeciesReferenceConstantValueAndStoichiometry" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->setSpeciesReferenceConstantValueAndStoichiometry();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeParameterRuleUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_removeParameterRuleUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeParameterRuleUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeParameterRuleUnits" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->removeParameterRuleUnits(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_convertStoichiometryMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_convertStoichiometryMath" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->convertStoichiometryMath();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_assignRequiredValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_assignRequiredValues" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->assignRequiredValues();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_dealWithModelUnits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_dealWithModelUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_dealWithModelUnits" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->dealWithModelUnits(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_dealWithModelUnits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_dealWithModelUnits" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->dealWithModelUnits();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_dealWithModelUnits(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_dealWithModelUnits", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_dealWithModelUnits__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_dealWithModelUnits__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_dealWithModelUnits'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::dealWithModelUnits(bool)\n"
    "    Model::dealWithModelUnits()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_dealWithStoichiometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_dealWithStoichiometry" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->dealWithStoichiometry();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_dealWithEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_dealWithEvents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_dealWithEvents" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_dealWithEvents" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->dealWithEvents(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeSpeciesTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeSpeciesTypes" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->removeSpeciesTypes();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeCompartmentTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeCompartmentTypes" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->removeCompartmentTypes();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_connectToChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_connectToChild" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->connectToChild();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getTypeCode" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (int)((Model const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getElementName" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (std::string *) &((Model const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_populateListFormulaUnitsData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_populateListFormulaUnitsData" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->populateListFormulaUnitsData();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_isPopulatedListFormulaUnitsData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isPopulatedListFormulaUnitsData" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)(arg1)->isPopulatedListFormulaUnitsData();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getFormulaUnitsDataForVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  FormulaUnitsData *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_getFormulaUnitsDataForVariable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getFormulaUnitsDataForVariable" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getFormulaUnitsDataForVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getFormulaUnitsDataForVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (FormulaUnitsData *)(arg1)->getFormulaUnitsDataForVariable((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FormulaUnitsData, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getFormulaUnitsDataForAssignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  FormulaUnitsData *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_getFormulaUnitsDataForAssignment", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getFormulaUnitsDataForAssignment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getFormulaUnitsDataForAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getFormulaUnitsDataForAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (FormulaUnitsData *)(arg1)->getFormulaUnitsDataForAssignment((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FormulaUnitsData, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_populateAllElementIdList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_populateAllElementIdList" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->populateAllElementIdList();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_isPopulatedAllElementIdList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isPopulatedAllElementIdList" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)((Model const *)arg1)->isPopulatedAllElementIdList();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getAllElementIdList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  IdList result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getAllElementIdList" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = ((Model const *)arg1)->getAllElementIdList();
  resultobj = SWIG_NewPointerObj((new IdList(static_cast< const IdList& >(result))), SWIGTYPE_p_IdList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_clearAllElementIdList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_clearAllElementIdList" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->clearAllElementIdList();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_populateAllElementMetaIdList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_populateAllElementMetaIdList" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->populateAllElementMetaIdList();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_isPopulatedAllElementMetaIdList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isPopulatedAllElementMetaIdList" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)((Model const *)arg1)->isPopulatedAllElementMetaIdList();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_getAllElementMetaIdList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  IdList result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getAllElementMetaIdList" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = ((Model const *)arg1)->getAllElementMetaIdList();
  resultobj = SWIG_NewPointerObj((new IdList(static_cast< const IdList& >(result))), SWIGTYPE_p_IdList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_clearAllElementMetaIdList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_clearAllElementMetaIdList" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  (arg1)->clearAllElementMetaIdList();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_hasRequiredElements" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)((Model const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeFunctionDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeFunctionDefinition" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeFunctionDefinition" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (FunctionDefinition *)(arg1)->removeFunctionDefinition(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeFunctionDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeFunctionDefinition" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_removeFunctionDefinition" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_removeFunctionDefinition" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (FunctionDefinition *)(arg1)->removeFunctionDefinition((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeFunctionDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_removeFunctionDefinition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_removeFunctionDefinition__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_removeFunctionDefinition__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_removeFunctionDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::removeFunctionDefinition(unsigned int)\n"
    "    Model::removeFunctionDefinition(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_removeUnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeUnitDefinition" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeUnitDefinition" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (UnitDefinition *)(arg1)->removeUnitDefinition(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeUnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeUnitDefinition" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_removeUnitDefinition" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_removeUnitDefinition" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (UnitDefinition *)(arg1)->removeUnitDefinition((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeUnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_removeUnitDefinition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_removeUnitDefinition__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_removeUnitDefinition__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_removeUnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::removeUnitDefinition(unsigned int)\n"
    "    Model::removeUnitDefinition(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_removeCompartmentType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeCompartmentType" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeCompartmentType" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CompartmentType *)(arg1)->removeCompartmentType(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeCompartmentType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeCompartmentType" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_removeCompartmentType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_removeCompartmentType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (CompartmentType *)(arg1)->removeCompartmentType((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeCompartmentType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_removeCompartmentType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_removeCompartmentType__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_removeCompartmentType__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_removeCompartmentType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::removeCompartmentType(unsigned int)\n"
    "    Model::removeCompartmentType(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_removeSpeciesType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeSpeciesType" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeSpeciesType" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SpeciesType *)(arg1)->removeSpeciesType(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeSpeciesType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeSpeciesType" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_removeSpeciesType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_removeSpeciesType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesType *)(arg1)->removeSpeciesType((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeSpeciesType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_removeSpeciesType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_removeSpeciesType__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_removeSpeciesType__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_removeSpeciesType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::removeSpeciesType(unsigned int)\n"
    "    Model::removeSpeciesType(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_removeCompartment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeCompartment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeCompartment" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Compartment *)(arg1)->removeCompartment(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeCompartment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeCompartment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_removeCompartment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_removeCompartment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Compartment *)(arg1)->removeCompartment((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeCompartment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_removeCompartment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_removeCompartment__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_removeCompartment__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_removeCompartment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::removeCompartment(unsigned int)\n"
    "    Model::removeCompartment(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_removeSpecies__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeSpecies" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeSpecies" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Species *)(arg1)->removeSpecies(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeSpecies__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeSpecies" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_removeSpecies" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_removeSpecies" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Species *)(arg1)->removeSpecies((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeSpecies(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_removeSpecies", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_removeSpecies__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_removeSpecies__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_removeSpecies'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::removeSpecies(unsigned int)\n"
    "    Model::removeSpecies(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_removeParameter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeParameter" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeParameter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Parameter *)(arg1)->removeParameter(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeParameter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeParameter" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_removeParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_removeParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Parameter *)(arg1)->removeParameter((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeParameter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_removeParameter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_removeParameter__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_removeParameter__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_removeParameter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::removeParameter(unsigned int)\n"
    "    Model::removeParameter(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_removeInitialAssignment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeInitialAssignment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeInitialAssignment" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (InitialAssignment *)(arg1)->removeInitialAssignment(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeInitialAssignment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeInitialAssignment" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_removeInitialAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_removeInitialAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (InitialAssignment *)(arg1)->removeInitialAssignment((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeInitialAssignment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_removeInitialAssignment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_removeInitialAssignment__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_removeInitialAssignment__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_removeInitialAssignment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::removeInitialAssignment(unsigned int)\n"
    "    Model::removeInitialAssignment(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_removeRule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeRule" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeRule" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Rule *)(arg1)->removeRule(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeRule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeRule" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_removeRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_removeRule" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Rule *)(arg1)->removeRule((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeRule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_removeRule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_removeRule__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_removeRule__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_removeRule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::removeRule(unsigned int)\n"
    "    Model::removeRule(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_removeRuleByVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Rule *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_removeRuleByVariable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeRuleByVariable" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_removeRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_removeRuleByVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Rule *)(arg1)->removeRuleByVariable((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Constraint *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_removeConstraint", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeConstraint" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeConstraint" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Constraint *)(arg1)->removeConstraint(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Constraint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeReaction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeReaction" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeReaction" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Reaction *)(arg1)->removeReaction(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeReaction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeReaction" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_removeReaction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_removeReaction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Reaction *)(arg1)->removeReaction((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeReaction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_removeReaction", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_removeReaction__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_removeReaction__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_removeReaction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::removeReaction(unsigned int)\n"
    "    Model::removeReaction(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_removeEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeEvent" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_removeEvent" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Event *)(arg1)->removeEvent(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_removeEvent" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_removeEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_removeEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Event *)(arg1)->removeEvent((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_removeEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Model_removeEvent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_removeEvent__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_removeEvent__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Model_removeEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Model::removeEvent(unsigned int)\n"
    "    Model::removeEvent(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Model_appendFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  Model *arg2 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_appendFrom", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_appendFrom" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_appendFrom" "', argument " "2"" of type '" "Model const *""'"); 
  }
  arg2 = reinterpret_cast< Model * >(argp2);
  result = (int)(arg1)->appendFrom((Model const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_enablePackageInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_enablePackageInternal", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_enablePackageInternal" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Model_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Model_enablePackageInternal" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->enablePackageInternal((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_updateSBMLNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_updateSBMLNamespace", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_updateSBMLNamespace" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Model_updateSBMLNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Model_updateSBMLNamespace" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  (arg1)->updateSBMLNamespace((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Model_renameIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  ListWrapper< SBase > *arg2 = 0 ;
  IdentifierTransformer *arg3 = (IdentifierTransformer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Model_renameIDs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_renameIDs" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ListWrapperT_SBase_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_renameIDs" "', argument " "2"" of type '" "ListWrapper< SBase > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_renameIDs" "', argument " "2"" of type '" "ListWrapper< SBase > &""'"); 
  }
  arg2 = reinterpret_cast< ListWrapper< SBase > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_IdentifierTransformer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Model_renameIDs" "', argument " "3"" of type '" "IdentifierTransformer *""'"); 
  }
  arg3 = reinterpret_cast< IdentifierTransformer * >(argp3);
  Model_renameIDs(arg1,*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Model_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Model, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Model_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLDocument_getDefaultLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_getDefaultLevel", 0, 0, 0)) SWIG_fail;
  result = (unsigned int)SBMLDocument::getDefaultLevel();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getDefaultVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_getDefaultVersion", 0, 0, 0)) SWIG_fail;
  result = (unsigned int)SBMLDocument::getDefaultVersion();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLDocument" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLDocument" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (SBMLDocument *)new SBMLDocument(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLDocument" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = (SBMLDocument *)new SBMLDocument(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLDocument__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (SBMLDocument *)new SBMLDocument();
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLDocument__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLDocument" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (SBMLDocument *)new SBMLDocument(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLDocument" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLDocument__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLDocument,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLDocument" "', argument " "1"" of type '" "SBMLDocument const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLDocument" "', argument " "1"" of type '" "SBMLDocument const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    try {
      result = (SBMLDocument *)new SBMLDocument((SBMLDocument const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLDocument(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLDocument", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLDocument__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLDocument__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLDocument, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLDocument__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SBMLDocument__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBMLDocument__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLDocument'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocument::SBMLDocument(unsigned int,unsigned int)\n"
    "    SBMLDocument::SBMLDocument(unsigned int)\n"
    "    SBMLDocument::SBMLDocument()\n"
    "    SBMLDocument::SBMLDocument(SBMLNamespaces *)\n"
    "    SBMLDocument::SBMLDocument(SBMLDocument const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLDocument *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_clone" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (SBMLDocument *)((SBMLDocument const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_isSetModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_isSetModel" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (bool)((SBMLDocument const *)arg1)->isSetModel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getModel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Model *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getModel" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (Model *)((SBMLDocument const *)arg1)->getModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Model, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getModel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Model *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getModel" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (Model *)(arg1)->getModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Model, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getModel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLDocument_getModel", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_getModel__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_getModel__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLDocument_getModel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocument::getModel() const\n"
    "    SBMLDocument::getModel()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getElementBySId" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getElementByMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_getElementByMetaId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getElementByMetaId" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementByMetaId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_expandFunctionDefinitions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_expandFunctionDefinitions" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (bool)(arg1)->expandFunctionDefinitions();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_expandInitialAssignments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_expandInitialAssignments" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (bool)(arg1)->expandInitialAssignments();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_setLevelAndVersion__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_setLevelAndVersion" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_setLevelAndVersion" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLDocument_setLevelAndVersion" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLDocument_setLevelAndVersion" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBMLDocument_setLevelAndVersion" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (bool)(arg1)->setLevelAndVersion(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_setLevelAndVersion__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_setLevelAndVersion" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_setLevelAndVersion" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLDocument_setLevelAndVersion" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLDocument_setLevelAndVersion" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (bool)(arg1)->setLevelAndVersion(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_setLevelAndVersion__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_setLevelAndVersion" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_setLevelAndVersion" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLDocument_setLevelAndVersion" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (bool)(arg1)->setLevelAndVersion(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_setLevelAndVersion(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLDocument_setLevelAndVersion", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBMLDocument_setLevelAndVersion__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBMLDocument_setLevelAndVersion__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SBMLDocument_setLevelAndVersion__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLDocument_setLevelAndVersion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocument::setLevelAndVersion(unsigned int,unsigned int,bool,bool)\n"
    "    SBMLDocument::setLevelAndVersion(unsigned int,unsigned int,bool)\n"
    "    SBMLDocument::setLevelAndVersion(unsigned int,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_updateSBMLNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_updateSBMLNamespace", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_updateSBMLNamespace" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLDocument_updateSBMLNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLDocument_updateSBMLNamespace" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  (arg1)->updateSBMLNamespace((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_setModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  Model *arg2 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_setModel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_setModel" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_setModel" "', argument " "2"" of type '" "Model const *""'"); 
  }
  arg2 = reinterpret_cast< Model * >(argp2);
  result = (int)(arg1)->setModel((Model const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_createModel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Model *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_createModel" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLDocument_createModel" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Model *)(arg1)->createModel(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Model, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_createModel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Model *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_createModel" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (Model *)(arg1)->createModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Model, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_createModel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLDocument_createModel", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_createModel__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBMLDocument_createModel__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLDocument_createModel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocument::createModel(std::string const)\n"
    "    SBMLDocument::createModel()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_setLocationURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_setLocationURI", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_setLocationURI" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_setLocationURI" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_setLocationURI" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->setLocationURI((std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getLocationURI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getLocationURI" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = ((SBMLDocument const *)arg1)->getLocationURI();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getLocationURI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getLocationURI" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (arg1)->getLocationURI();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getLocationURI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLDocument_getLocationURI", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_getLocationURI__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_getLocationURI__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLDocument_getLocationURI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocument::getLocationURI() const\n"
    "    SBMLDocument::getLocationURI()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_setConsistencyChecks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  SBMLErrorCategory_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_setConsistencyChecks", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_setConsistencyChecks" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_setConsistencyChecks" "', argument " "2"" of type '" "SBMLErrorCategory_t""'");
  } 
  arg2 = static_cast< SBMLErrorCategory_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLDocument_setConsistencyChecks" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setConsistencyChecks(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_setConsistencyChecksForConversion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  SBMLErrorCategory_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_setConsistencyChecksForConversion", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_setConsistencyChecksForConversion" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_setConsistencyChecksForConversion" "', argument " "2"" of type '" "SBMLErrorCategory_t""'");
  } 
  arg2 = static_cast< SBMLErrorCategory_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLDocument_setConsistencyChecksForConversion" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setConsistencyChecksForConversion(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkConsistency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkConsistency" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)(arg1)->checkConsistency();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkConsistencyWithStrictUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkConsistencyWithStrictUnits" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)(arg1)->checkConsistencyWithStrictUnits();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_validateSBML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_validateSBML" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)(arg1)->validateSBML();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkInternalConsistency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkInternalConsistency" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)(arg1)->checkInternalConsistency();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL1Compatibility__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkL1Compatibility" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_checkL1Compatibility" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (unsigned int)(arg1)->checkL1Compatibility(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL1Compatibility__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkL1Compatibility" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)(arg1)->checkL1Compatibility();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL1Compatibility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLDocument_checkL1Compatibility", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_checkL1Compatibility__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBMLDocument_checkL1Compatibility__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLDocument_checkL1Compatibility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocument::checkL1Compatibility(bool)\n"
    "    SBMLDocument::checkL1Compatibility()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL2v1Compatibility__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkL2v1Compatibility" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_checkL2v1Compatibility" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (unsigned int)(arg1)->checkL2v1Compatibility(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL2v1Compatibility__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkL2v1Compatibility" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)(arg1)->checkL2v1Compatibility();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL2v1Compatibility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLDocument_checkL2v1Compatibility", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_checkL2v1Compatibility__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBMLDocument_checkL2v1Compatibility__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLDocument_checkL2v1Compatibility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocument::checkL2v1Compatibility(bool)\n"
    "    SBMLDocument::checkL2v1Compatibility()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL2v2Compatibility__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkL2v2Compatibility" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_checkL2v2Compatibility" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (unsigned int)(arg1)->checkL2v2Compatibility(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL2v2Compatibility__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkL2v2Compatibility" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)(arg1)->checkL2v2Compatibility();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL2v2Compatibility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLDocument_checkL2v2Compatibility", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_checkL2v2Compatibility__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBMLDocument_checkL2v2Compatibility__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLDocument_checkL2v2Compatibility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocument::checkL2v2Compatibility(bool)\n"
    "    SBMLDocument::checkL2v2Compatibility()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL2v3Compatibility__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkL2v3Compatibility" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_checkL2v3Compatibility" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (unsigned int)(arg1)->checkL2v3Compatibility(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL2v3Compatibility__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkL2v3Compatibility" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)(arg1)->checkL2v3Compatibility();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL2v3Compatibility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLDocument_checkL2v3Compatibility", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_checkL2v3Compatibility__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBMLDocument_checkL2v3Compatibility__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLDocument_checkL2v3Compatibility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocument::checkL2v3Compatibility(bool)\n"
    "    SBMLDocument::checkL2v3Compatibility()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL2v4Compatibility(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkL2v4Compatibility" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)(arg1)->checkL2v4Compatibility();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL2v5Compatibility(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkL2v5Compatibility" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)(arg1)->checkL2v5Compatibility();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL3v1Compatibility(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkL3v1Compatibility" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)(arg1)->checkL3v1Compatibility();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_checkL3v2Compatibility(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_checkL3v2Compatibility" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)(arg1)->checkL3v2Compatibility();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBMLError *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_getError", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getError" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_getError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBMLError *)((SBMLDocument const *)arg1)->getError(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getErrorWithSeverity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SBMLError *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_getErrorWithSeverity", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getErrorWithSeverity" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_getErrorWithSeverity" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLDocument_getErrorWithSeverity" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (SBMLError *)((SBMLDocument const *)arg1)->getErrorWithSeverity(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getNumErrors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getNumErrors" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)((SBMLDocument const *)arg1)->getNumErrors();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getNumErrors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getNumErrors" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_getNumErrors" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (unsigned int)((SBMLDocument const *)arg1)->getNumErrors(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getNumErrors(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLDocument_getNumErrors", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_getNumErrors__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBMLDocument_getNumErrors__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLDocument_getNumErrors'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocument::getNumErrors() const\n"
    "    SBMLDocument::getNumErrors(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_printErrors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_printErrors" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_printErrors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_printErrors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ((SBMLDocument const *)arg1)->printErrors(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_printErrors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_printErrors" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ((SBMLDocument const *)arg1)->printErrors();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_printErrors__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::ostream *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_printErrors" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_printErrors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_printErrors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLDocument_printErrors" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ((SBMLDocument const *)arg1)->printErrors(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_printErrors(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLDocument_printErrors", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_printErrors__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBMLDocument_printErrors__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBMLDocument_printErrors__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLDocument_printErrors'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocument::printErrors(std::ostream &) const\n"
    "    SBMLDocument::printErrors() const\n"
    "    SBMLDocument::printErrors(std::ostream &,unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_connectToChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_connectToChild" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  (arg1)->connectToChild();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_convert", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_convert" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_convert" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_convert" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (int)(arg1)->convert((ConversionProperties const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_enablePackageInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_enablePackageInternal", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_enablePackageInternal" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBMLDocument_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLDocument_enablePackageInternal" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->enablePackageInternal((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getTypeCode" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (int)((SBMLDocument const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getElementName" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (std::string *) &((SBMLDocument const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getErrorLog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLErrorLog *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getErrorLog" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (SBMLErrorLog *)(arg1)->getErrorLog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getErrorLog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLErrorLog *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getErrorLog" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (SBMLErrorLog *)((SBMLDocument const *)arg1)->getErrorLog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getErrorLog(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLDocument_getErrorLog", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_getErrorLog__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLDocument, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLDocument_getErrorLog__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLDocument_getErrorLog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocument::getErrorLog()\n"
    "    SBMLDocument::getErrorLog() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNamespaces *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getNamespaces" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (XMLNamespaces *)((SBMLDocument const *)arg1)->getNamespaces();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_enableDefaultNS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_enableDefaultNS", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_enableDefaultNS" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_enableDefaultNS" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_enableDefaultNS" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLDocument_enableDefaultNS" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (int)(arg1)->enableDefaultNS((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_isEnabledDefaultNS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_isEnabledDefaultNS", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_isEnabledDefaultNS" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_isEnabledDefaultNS" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_isEnabledDefaultNS" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->isEnabledDefaultNS((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_setPackageRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_setPackageRequired", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_setPackageRequired" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_setPackageRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_setPackageRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLDocument_setPackageRequired" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (int)(arg1)->setPackageRequired((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getPackageRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_getPackageRequired", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getPackageRequired" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_getPackageRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_getPackageRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->getPackageRequired((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_isSetPackageRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_isSetPackageRequired", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_isSetPackageRequired" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_isSetPackageRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_isSetPackageRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->isSetPackageRequired((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_isIgnoredPackage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_isIgnoredPackage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_isIgnoredPackage" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_isIgnoredPackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_isIgnoredPackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->isIgnoredPackage((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_isDisabledIgnoredPackage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_isDisabledIgnoredPackage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_isDisabledIgnoredPackage" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_isDisabledIgnoredPackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_isDisabledIgnoredPackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->isDisabledIgnoredPackage((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_setPkgRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_setPkgRequired", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_setPkgRequired" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_setPkgRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_setPkgRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLDocument_setPkgRequired" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (int)(arg1)->setPkgRequired((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getPkgRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_getPkgRequired", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getPkgRequired" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_getPkgRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_getPkgRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->getPkgRequired((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_isSetPkgRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_isSetPkgRequired", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_isSetPkgRequired" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_isSetPkgRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_isSetPkgRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->isSetPkgRequired((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_isIgnoredPkg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_isIgnoredPkg", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_isIgnoredPkg" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_isIgnoredPkg" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_isIgnoredPkg" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->isIgnoredPkg((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getApplicableValidators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned char result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getApplicableValidators" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned char)((SBMLDocument const *)arg1)->getApplicableValidators();
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getConversionValidators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned char result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getConversionValidators" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned char)((SBMLDocument const *)arg1)->getConversionValidators();
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_setApplicableValidators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_setApplicableValidators", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_setApplicableValidators" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_setApplicableValidators" "', argument " "2"" of type '" "unsigned char""'");
  } 
  arg2 = static_cast< unsigned char >(val2);
  (arg1)->setApplicableValidators(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_setConversionValidators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_setConversionValidators", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_setConversionValidators" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_setConversionValidators" "', argument " "2"" of type '" "unsigned char""'");
  } 
  arg2 = static_cast< unsigned char >(val2);
  (arg1)->setConversionValidators(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getNumValidators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getNumValidators" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (unsigned int)((SBMLDocument const *)arg1)->getNumValidators();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_clearValidators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_clearValidators" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (int)(arg1)->clearValidators();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_addValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  SBMLValidator *arg2 = (SBMLValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_addValidator", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_addValidator" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_addValidator" "', argument " "2"" of type '" "SBMLValidator const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLValidator * >(argp2);
  result = (int)(arg1)->addValidator((SBMLValidator const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBMLValidator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_getValidator", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getValidator" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_getValidator" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBMLValidator *)(arg1)->getValidator(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLValidator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_addUnknownPackageRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_addUnknownPackageRequired", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_addUnknownPackageRequired" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_addUnknownPackageRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_addUnknownPackageRequired" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBMLDocument_addUnknownPackageRequired" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_addUnknownPackageRequired" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLDocument_addUnknownPackageRequired" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (int)(arg1)->addUnknownPackageRequired((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_hasUnknownPackage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_hasUnknownPackage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_hasUnknownPackage" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLDocument_hasUnknownPackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLDocument_hasUnknownPackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->hasUnknownPackage((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getNumUnknownPackages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getNumUnknownPackages" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (int)((SBMLDocument const *)arg1)->getNumUnknownPackages();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getUnknownPackageURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_getUnknownPackageURI", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getUnknownPackageURI" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_getUnknownPackageURI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((SBMLDocument const *)arg1)->getUnknownPackageURI(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocument_getUnknownPackagePrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocument_getUnknownPackagePrefix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocument_getUnknownPackagePrefix" "', argument " "1"" of type '" "SBMLDocument const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocument_getUnknownPackagePrefix" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((SBMLDocument const *)arg1)->getUnknownPackagePrefix(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLDocument_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLDocument, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLDocument_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FunctionDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FunctionDefinition" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FunctionDefinition" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (FunctionDefinition *)new FunctionDefinition(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FunctionDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FunctionDefinition" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (FunctionDefinition *)new FunctionDefinition(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FunctionDefinition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FunctionDefinition" "', argument " "1"" of type '" "FunctionDefinition *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FunctionDefinition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FunctionDefinition,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FunctionDefinition" "', argument " "1"" of type '" "FunctionDefinition const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FunctionDefinition" "', argument " "1"" of type '" "FunctionDefinition const &""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  {
    try {
      result = (FunctionDefinition *)new FunctionDefinition((FunctionDefinition const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FunctionDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FunctionDefinition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FunctionDefinition__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FunctionDefinition, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FunctionDefinition__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FunctionDefinition__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FunctionDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FunctionDefinition::FunctionDefinition(unsigned int,unsigned int)\n"
    "    FunctionDefinition::FunctionDefinition(SBMLNamespaces *)\n"
    "    FunctionDefinition::FunctionDefinition(FunctionDefinition const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FunctionDefinition *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_clone" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (FunctionDefinition *)((FunctionDefinition const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_getId" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (std::string *) &((FunctionDefinition const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_getName" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (std::string *) &((FunctionDefinition const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_getMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_getMath" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (ASTNode *)((FunctionDefinition const *)arg1)->getMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_isSetId" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (bool)((FunctionDefinition const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_isSetName" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (bool)((FunctionDefinition const *)arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_isSetMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_isSetMath" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (bool)((FunctionDefinition const *)arg1)->isSetMath();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "FunctionDefinition_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_setId" "', argument " "1"" of type '" "FunctionDefinition *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionDefinition_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionDefinition_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "FunctionDefinition_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_setName" "', argument " "1"" of type '" "FunctionDefinition *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionDefinition_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionDefinition_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_setMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "FunctionDefinition_setMath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_setMath" "', argument " "1"" of type '" "FunctionDefinition *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionDefinition_setMath" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (int)(arg1)->setMath((ASTNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_unsetName" "', argument " "1"" of type '" "FunctionDefinition *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_getArgument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ASTNode *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_getArgument" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FunctionDefinition_getArgument" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ASTNode *)((FunctionDefinition const *)arg1)->getArgument(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_getArgument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  ASTNode *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_getArgument" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionDefinition_getArgument" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionDefinition_getArgument" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ASTNode *)((FunctionDefinition const *)arg1)->getArgument((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_getArgument(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionDefinition_getArgument", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FunctionDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FunctionDefinition_getArgument__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FunctionDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FunctionDefinition_getArgument__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionDefinition_getArgument'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FunctionDefinition::getArgument(unsigned int) const\n"
    "    FunctionDefinition::getArgument(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_getBody__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ASTNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_getBody" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (ASTNode *)((FunctionDefinition const *)arg1)->getBody();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_getBody__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ASTNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_getBody" "', argument " "1"" of type '" "FunctionDefinition *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (ASTNode *)(arg1)->getBody();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_getBody(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FunctionDefinition_getBody", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FunctionDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FunctionDefinition_getBody__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FunctionDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FunctionDefinition_getBody__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FunctionDefinition_getBody'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FunctionDefinition::getBody() const\n"
    "    FunctionDefinition::getBody()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_isSetBody(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_isSetBody" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (bool)((FunctionDefinition const *)arg1)->isSetBody();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_getNumArguments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_getNumArguments" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (unsigned int)((FunctionDefinition const *)arg1)->getNumArguments();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_getTypeCode" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (int)((FunctionDefinition const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_getElementName" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (std::string *) &((FunctionDefinition const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_hasRequiredAttributes" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (bool)((FunctionDefinition const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_hasRequiredElements" "', argument " "1"" of type '" "FunctionDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  result = (bool)((FunctionDefinition const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FunctionDefinition_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FunctionDefinition *arg1 = (FunctionDefinition *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FunctionDefinition_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionDefinition_renameUnitSIdRefs" "', argument " "1"" of type '" "FunctionDefinition *""'"); 
  }
  arg1 = reinterpret_cast< FunctionDefinition * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionDefinition_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionDefinition_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FunctionDefinition_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionDefinition_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *FunctionDefinition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FunctionDefinition, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FunctionDefinition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfFunctionDefinitions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfFunctionDefinitions *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfFunctionDefinitions" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfFunctionDefinitions" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfFunctionDefinitions *)new ListOfFunctionDefinitions(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfFunctionDefinitions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfFunctionDefinitions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfFunctionDefinitions *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfFunctionDefinitions" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfFunctionDefinitions *)new ListOfFunctionDefinitions(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfFunctionDefinitions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfFunctionDefinitions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfFunctionDefinitions", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfFunctionDefinitions__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfFunctionDefinitions__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfFunctionDefinitions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfFunctionDefinitions::ListOfFunctionDefinitions(unsigned int,unsigned int)\n"
    "    ListOfFunctionDefinitions::ListOfFunctionDefinitions(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfFunctionDefinitions_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfFunctionDefinitions *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfFunctionDefinitions_clone" "', argument " "1"" of type '" "ListOfFunctionDefinitions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfFunctionDefinitions * >(argp1);
  result = (ListOfFunctionDefinitions *)((ListOfFunctionDefinitions const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfFunctionDefinitions, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfFunctionDefinitions_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfFunctionDefinitions_getItemTypeCode" "', argument " "1"" of type '" "ListOfFunctionDefinitions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfFunctionDefinitions * >(argp1);
  result = (int)((ListOfFunctionDefinitions const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfFunctionDefinitions_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfFunctionDefinitions_getElementName" "', argument " "1"" of type '" "ListOfFunctionDefinitions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfFunctionDefinitions * >(argp1);
  result = (std::string *) &((ListOfFunctionDefinitions const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfFunctionDefinitions_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfFunctionDefinitions_get" "', argument " "1"" of type '" "ListOfFunctionDefinitions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfFunctionDefinitions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfFunctionDefinitions_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (FunctionDefinition *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfFunctionDefinitions_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfFunctionDefinitions_get" "', argument " "1"" of type '" "ListOfFunctionDefinitions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfFunctionDefinitions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfFunctionDefinitions_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (FunctionDefinition *)((ListOfFunctionDefinitions const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfFunctionDefinitions_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfFunctionDefinitions_get" "', argument " "1"" of type '" "ListOfFunctionDefinitions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfFunctionDefinitions * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfFunctionDefinitions_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfFunctionDefinitions_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (FunctionDefinition *)(arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfFunctionDefinitions_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfFunctionDefinitions_get" "', argument " "1"" of type '" "ListOfFunctionDefinitions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfFunctionDefinitions * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfFunctionDefinitions_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfFunctionDefinitions_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (FunctionDefinition *)((ListOfFunctionDefinitions const *)arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfFunctionDefinitions_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfFunctionDefinitions_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfFunctionDefinitions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfFunctionDefinitions_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfFunctionDefinitions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfFunctionDefinitions_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfFunctionDefinitions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfFunctionDefinitions_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfFunctionDefinitions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfFunctionDefinitions_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfFunctionDefinitions_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfFunctionDefinitions::get(unsigned int)\n"
    "    ListOfFunctionDefinitions::get(unsigned int) const\n"
    "    ListOfFunctionDefinitions::get(std::string const &)\n"
    "    ListOfFunctionDefinitions::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfFunctionDefinitions_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfFunctionDefinitions_remove" "', argument " "1"" of type '" "ListOfFunctionDefinitions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfFunctionDefinitions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfFunctionDefinitions_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (FunctionDefinition *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfFunctionDefinitions_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  FunctionDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfFunctionDefinitions_remove" "', argument " "1"" of type '" "ListOfFunctionDefinitions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfFunctionDefinitions * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfFunctionDefinitions_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfFunctionDefinitions_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (FunctionDefinition *)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FunctionDefinition, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfFunctionDefinitions_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfFunctionDefinitions_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfFunctionDefinitions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfFunctionDefinitions_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfFunctionDefinitions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfFunctionDefinitions_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfFunctionDefinitions_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfFunctionDefinitions::remove(unsigned int)\n"
    "    ListOfFunctionDefinitions::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListOfFunctionDefinitions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfFunctionDefinitions *arg1 = (ListOfFunctionDefinitions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfFunctionDefinitions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfFunctionDefinitions" "', argument " "1"" of type '" "ListOfFunctionDefinitions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfFunctionDefinitions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfFunctionDefinitions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfFunctionDefinitions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfFunctionDefinitions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_UnitKind_equals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitKind_t arg1 ;
  UnitKind_t arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitKind_equals", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UnitKind_equals" "', argument " "1"" of type '" "UnitKind_t""'");
  } 
  arg1 = static_cast< UnitKind_t >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitKind_equals" "', argument " "2"" of type '" "UnitKind_t""'");
  } 
  arg2 = static_cast< UnitKind_t >(val2);
  result = (int)UnitKind_equals(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitKind_forName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  UnitKind_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitKind_forName" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (UnitKind_t)UnitKind_forName((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitKind_toString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitKind_t arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UnitKind_toString" "', argument " "1"" of type '" "UnitKind_t""'");
  } 
  arg1 = static_cast< UnitKind_t >(val1);
  result = (char *)UnitKind_toString(arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitKind_isValidUnitKindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitKind_isValidUnitKindString", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitKind_isValidUnitKindString" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitKind_isValidUnitKindString" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UnitKind_isValidUnitKindString" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (int)UnitKind_isValidUnitKindString((char const *)arg1,arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Unit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Unit *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Unit" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Unit" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Unit *)new Unit(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Unit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Unit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Unit *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Unit" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (Unit *)new Unit(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Unit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Unit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Unit" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Unit__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Unit *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Unit *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Unit,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Unit" "', argument " "1"" of type '" "Unit const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Unit" "', argument " "1"" of type '" "Unit const &""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  {
    try {
      result = (Unit *)new Unit((Unit const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Unit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Unit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Unit", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Unit__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Unit, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Unit__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Unit__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Unit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Unit::Unit(unsigned int,unsigned int)\n"
    "    Unit::Unit(SBMLNamespaces *)\n"
    "    Unit::Unit(Unit const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Unit_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Unit *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_clone" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (Unit *)((Unit const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Unit, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_initDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_initDefaults" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  (arg1)->initDefaults();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_getKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  UnitKind_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_getKind" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (UnitKind_t)((Unit const *)arg1)->getKind();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_getExponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_getExponent" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (int)((Unit const *)arg1)->getExponent();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_getExponentAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_getExponentAsDouble" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (double)((Unit const *)arg1)->getExponentAsDouble();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_getScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_getScale" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (int)((Unit const *)arg1)->getScale();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_getMultiplier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_getMultiplier" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (double)((Unit const *)arg1)->getMultiplier();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_getOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_getOffset" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (double)((Unit const *)arg1)->getOffset();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isAmpere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isAmpere" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isAmpere();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isAvogadro(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isAvogadro" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isAvogadro();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isBecquerel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isBecquerel" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isBecquerel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isCandela(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isCandela" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isCandela();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isCelsius(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isCelsius" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isCelsius();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isCoulomb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isCoulomb" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isCoulomb();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isDimensionless(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isDimensionless" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isDimensionless();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isFarad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isFarad" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isFarad();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isGram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isGram" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isGram();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isGray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isGray" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isGray();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isHenry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isHenry" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isHenry();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isHertz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isHertz" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isHertz();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isItem" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isItem();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isJoule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isJoule" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isJoule();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isKatal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isKatal" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isKatal();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isKelvin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isKelvin" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isKelvin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isKilogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isKilogram" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isKilogram();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isLitre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isLitre" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isLitre();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isLumen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isLumen" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isLumen();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isLux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isLux" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isLux();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isMetre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isMetre" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isMetre();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isMole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isMole" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isMole();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isNewton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isNewton" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isNewton();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isOhm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isOhm" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isOhm();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isPascal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isPascal" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isPascal();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isRadian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isRadian" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isRadian();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isSecond" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isSecond();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isSiemens(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isSiemens" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isSiemens();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isSievert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isSievert" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isSievert();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isSteradian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isSteradian" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isSteradian();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isTesla(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isTesla" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isTesla();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isVolt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isVolt" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isVolt();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isWatt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isWatt" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isWatt();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isWeber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isWeber" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isWeber();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isSetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isSetKind" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isSetKind();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isSetExponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isSetExponent" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isSetExponent();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isSetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isSetScale" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isSetScale();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isSetMultiplier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isSetMultiplier" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isSetMultiplier();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isSetOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isSetOffset" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isSetOffset();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_setKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  UnitKind_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Unit_setKind", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_setKind" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Unit_setKind" "', argument " "2"" of type '" "UnitKind_t""'");
  } 
  arg2 = static_cast< UnitKind_t >(val2);
  result = (int)(arg1)->setKind(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_setExponent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_setExponent" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Unit_setExponent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->setExponent(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_setExponent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_setExponent" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Unit_setExponent" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->setExponent(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_setExponent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Unit_setExponent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Unit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Unit_setExponent__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Unit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Unit_setExponent__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Unit_setExponent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Unit::setExponent(int)\n"
    "    Unit::setExponent(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Unit_setScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Unit_setScale", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_setScale" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Unit_setScale" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->setScale(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_setMultiplier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Unit_setMultiplier", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_setMultiplier" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Unit_setMultiplier" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->setMultiplier(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_setOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Unit_setOffset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_setOffset" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Unit_setOffset" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->setOffset(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_unsetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_unsetKind" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (int)(arg1)->unsetKind();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_unsetExponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_unsetExponent" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (int)(arg1)->unsetExponent();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_unsetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_unsetScale" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (int)(arg1)->unsetScale();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_unsetMultiplier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_unsetMultiplier" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (int)(arg1)->unsetMultiplier();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_unsetOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_unsetOffset" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (int)(arg1)->unsetOffset();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_getTypeCode" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (int)((Unit const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_getElementName" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (std::string *) &((Unit const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isBuiltIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Unit_isBuiltIn", 2, 2, swig_obj)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isBuiltIn" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Unit_isBuiltIn" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Unit_isBuiltIn" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (bool)Unit::isBuiltIn((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1,arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isUnitKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Unit_isUnitKind", 3, 3, swig_obj)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isUnitKind" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Unit_isUnitKind" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Unit_isUnitKind" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Unit_isUnitKind" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (bool)Unit::isUnitKind((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1,arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_areIdentical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  Unit *arg2 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Unit_areIdentical", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_areIdentical" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Unit_areIdentical" "', argument " "2"" of type '" "Unit *""'"); 
  }
  arg2 = reinterpret_cast< Unit * >(argp2);
  result = (bool)Unit::areIdentical(arg1,arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_areEquivalent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  Unit *arg2 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Unit_areEquivalent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_areEquivalent" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Unit_areEquivalent" "', argument " "2"" of type '" "Unit *""'"); 
  }
  arg2 = reinterpret_cast< Unit * >(argp2);
  result = (bool)Unit::areEquivalent(arg1,arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_removeScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_removeScale" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (int)Unit::removeScale(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_merge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  Unit *arg2 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Unit_merge", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_merge" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Unit_merge" "', argument " "2"" of type '" "Unit *""'"); 
  }
  arg2 = reinterpret_cast< Unit * >(argp2);
  Unit::merge(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_convertToSI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  UnitDefinition *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_convertToSI" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (UnitDefinition *)Unit::convertToSI((Unit const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_hasRequiredAttributes" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_setExponentUnitChecking(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Unit_setExponentUnitChecking", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_setExponentUnitChecking" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Unit_setExponentUnitChecking" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setExponentUnitChecking(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_getExponentUnitChecking__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_getExponentUnitChecking" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (double)(arg1)->getExponentUnitChecking();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_getExponentUnitChecking__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_getExponentUnitChecking" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (double)((Unit const *)arg1)->getExponentUnitChecking();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_getExponentUnitChecking(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Unit_getExponentUnitChecking", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Unit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Unit_getExponentUnitChecking__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Unit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Unit_getExponentUnitChecking__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Unit_getExponentUnitChecking'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Unit::getExponentUnitChecking()\n"
    "    Unit::getExponentUnitChecking() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Unit_isUnitChecking__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isUnitChecking" "', argument " "1"" of type '" "Unit *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)(arg1)->isUnitChecking();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isUnitChecking__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Unit *arg1 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Unit_isUnitChecking" "', argument " "1"" of type '" "Unit const *""'"); 
  }
  arg1 = reinterpret_cast< Unit * >(argp1);
  result = (bool)((Unit const *)arg1)->isUnitChecking();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Unit_isUnitChecking(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Unit_isUnitChecking", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Unit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Unit_isUnitChecking__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Unit, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Unit_isUnitChecking__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Unit_isUnitChecking'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Unit::isUnitChecking()\n"
    "    Unit::isUnitChecking() const\n");
  return 0;
}


SWIGINTERN PyObject *Unit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Unit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Unit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfUnits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfUnits *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfUnits" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfUnits" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfUnits *)new ListOfUnits(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfUnits, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfUnits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfUnits *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfUnits" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfUnits *)new ListOfUnits(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfUnits, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfUnits(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfUnits", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfUnits__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfUnits__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfUnits'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfUnits::ListOfUnits(unsigned int,unsigned int)\n"
    "    ListOfUnits::ListOfUnits(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfUnits_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfUnits *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnits_clone" "', argument " "1"" of type '" "ListOfUnits const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnits * >(argp1);
  result = (ListOfUnits *)((ListOfUnits const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfUnits, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnits_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnits_getItemTypeCode" "', argument " "1"" of type '" "ListOfUnits const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnits * >(argp1);
  result = (int)((ListOfUnits const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnits_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnits_getElementName" "', argument " "1"" of type '" "ListOfUnits const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnits * >(argp1);
  result = (std::string *) &((ListOfUnits const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnits_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Unit *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnits_get" "', argument " "1"" of type '" "ListOfUnits *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnits * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfUnits_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Unit *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Unit, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnits_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Unit *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnits_get" "', argument " "1"" of type '" "ListOfUnits const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnits * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfUnits_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Unit *)((ListOfUnits const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Unit, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnits_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfUnits_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfUnits, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfUnits_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfUnits, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfUnits_get__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfUnits_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfUnits::get(unsigned int)\n"
    "    ListOfUnits::get(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfUnits_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Unit *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOfUnits_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnits, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnits_remove" "', argument " "1"" of type '" "ListOfUnits *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnits * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfUnits_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Unit *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Unit, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListOfUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfUnits *arg1 = (ListOfUnits *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnits, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfUnits" "', argument " "1"" of type '" "ListOfUnits *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnits * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfUnits_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfUnits, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfUnits_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnitDefinition" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UnitDefinition" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (UnitDefinition *)new UnitDefinition(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnitDefinition" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (UnitDefinition *)new UnitDefinition(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UnitDefinition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnitDefinition" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitDefinition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_UnitDefinition,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnitDefinition" "', argument " "1"" of type '" "UnitDefinition const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnitDefinition" "', argument " "1"" of type '" "UnitDefinition const &""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  {
    try {
      result = (UnitDefinition *)new UnitDefinition((UnitDefinition const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnitDefinition", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnitDefinition__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_UnitDefinition, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnitDefinition__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UnitDefinition__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UnitDefinition::UnitDefinition(unsigned int,unsigned int)\n"
    "    UnitDefinition::UnitDefinition(SBMLNamespaces *)\n"
    "    UnitDefinition::UnitDefinition(UnitDefinition const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  UnitDefinition *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_clone" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (UnitDefinition *)((UnitDefinition const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitDefinition_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_getElementBySId" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnitDefinition_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnitDefinition_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getElementByMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitDefinition_getElementByMetaId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_getElementByMetaId" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnitDefinition_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnitDefinition_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementByMetaId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_getId" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (std::string *) &((UnitDefinition const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_getName" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (std::string *) &((UnitDefinition const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isSetId" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (bool)((UnitDefinition const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isSetName" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (bool)((UnitDefinition const *)arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitDefinition_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_setId" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnitDefinition_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnitDefinition_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitDefinition_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_setName" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnitDefinition_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnitDefinition_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_unsetName" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfArea__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfArea" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitDefinition_isVariantOfArea" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfArea(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfArea__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfArea" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfArea();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfArea(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnitDefinition_isVariantOfArea", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UnitDefinition_isVariantOfArea__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UnitDefinition_isVariantOfArea__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnitDefinition_isVariantOfArea'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UnitDefinition::isVariantOfArea(bool) const\n"
    "    UnitDefinition::isVariantOfArea() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfLength__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfLength" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitDefinition_isVariantOfLength" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfLength(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfLength" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfLength();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfLength(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnitDefinition_isVariantOfLength", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UnitDefinition_isVariantOfLength__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UnitDefinition_isVariantOfLength__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnitDefinition_isVariantOfLength'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UnitDefinition::isVariantOfLength(bool) const\n"
    "    UnitDefinition::isVariantOfLength() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfSubstance__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfSubstance" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitDefinition_isVariantOfSubstance" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfSubstance(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfSubstance__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfSubstance" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfSubstance();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfSubstance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnitDefinition_isVariantOfSubstance", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UnitDefinition_isVariantOfSubstance__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UnitDefinition_isVariantOfSubstance__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnitDefinition_isVariantOfSubstance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UnitDefinition::isVariantOfSubstance(bool) const\n"
    "    UnitDefinition::isVariantOfSubstance() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfTime" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitDefinition_isVariantOfTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfTime(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfTime" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfTime();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfTime(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnitDefinition_isVariantOfTime", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UnitDefinition_isVariantOfTime__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UnitDefinition_isVariantOfTime__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnitDefinition_isVariantOfTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UnitDefinition::isVariantOfTime(bool) const\n"
    "    UnitDefinition::isVariantOfTime() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfVolume__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfVolume" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitDefinition_isVariantOfVolume" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfVolume(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfVolume__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfVolume" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfVolume();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfVolume(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnitDefinition_isVariantOfVolume", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UnitDefinition_isVariantOfVolume__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UnitDefinition_isVariantOfVolume__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnitDefinition_isVariantOfVolume'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UnitDefinition::isVariantOfVolume(bool) const\n"
    "    UnitDefinition::isVariantOfVolume() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfDimensionless__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfDimensionless" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitDefinition_isVariantOfDimensionless" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfDimensionless(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfDimensionless__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfDimensionless" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfDimensionless();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfDimensionless(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnitDefinition_isVariantOfDimensionless", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UnitDefinition_isVariantOfDimensionless__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UnitDefinition_isVariantOfDimensionless__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnitDefinition_isVariantOfDimensionless'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UnitDefinition::isVariantOfDimensionless(bool) const\n"
    "    UnitDefinition::isVariantOfDimensionless() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfMass__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfMass" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitDefinition_isVariantOfMass" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfMass(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfMass__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfMass" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfMass();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfMass(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnitDefinition_isVariantOfMass", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UnitDefinition_isVariantOfMass__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UnitDefinition_isVariantOfMass__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnitDefinition_isVariantOfMass'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UnitDefinition::isVariantOfMass(bool) const\n"
    "    UnitDefinition::isVariantOfMass() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfSubstancePerTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfSubstancePerTime" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitDefinition_isVariantOfSubstancePerTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfSubstancePerTime(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfSubstancePerTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_isVariantOfSubstancePerTime" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (bool)((UnitDefinition const *)arg1)->isVariantOfSubstancePerTime();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_isVariantOfSubstancePerTime(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnitDefinition_isVariantOfSubstancePerTime", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UnitDefinition_isVariantOfSubstancePerTime__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UnitDefinition_isVariantOfSubstancePerTime__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnitDefinition_isVariantOfSubstancePerTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UnitDefinition::isVariantOfSubstancePerTime(bool) const\n"
    "    UnitDefinition::isVariantOfSubstancePerTime() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_addUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  Unit *arg2 = (Unit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitDefinition_addUnit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_addUnit" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Unit, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnitDefinition_addUnit" "', argument " "2"" of type '" "Unit const *""'"); 
  }
  arg2 = reinterpret_cast< Unit * >(argp2);
  result = (int)(arg1)->addUnit((Unit const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_createUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Unit *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_createUnit" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (Unit *)(arg1)->createUnit();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Unit, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getListOfUnits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfUnits *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_getListOfUnits" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (ListOfUnits *)((UnitDefinition const *)arg1)->getListOfUnits();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfUnits, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getListOfUnits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfUnits *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_getListOfUnits" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (ListOfUnits *)(arg1)->getListOfUnits();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfUnits, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getListOfUnits(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnitDefinition_getListOfUnits", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UnitDefinition_getListOfUnits__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UnitDefinition_getListOfUnits__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnitDefinition_getListOfUnits'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UnitDefinition::getListOfUnits() const\n"
    "    UnitDefinition::getListOfUnits()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getUnit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Unit *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_getUnit" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitDefinition_getUnit" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Unit *)(arg1)->getUnit(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Unit, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Unit *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_getUnit" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitDefinition_getUnit" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Unit *)((UnitDefinition const *)arg1)->getUnit(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Unit, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getUnit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnitDefinition_getUnit", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UnitDefinition_getUnit__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UnitDefinition_getUnit__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnitDefinition_getUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UnitDefinition::getUnit(unsigned int)\n"
    "    UnitDefinition::getUnit(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getNumUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_getNumUnits" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (unsigned int)((UnitDefinition const *)arg1)->getNumUnits();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_removeUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Unit *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitDefinition_removeUnit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_removeUnit" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitDefinition_removeUnit" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Unit *)(arg1)->removeUnit(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Unit, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_connectToChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_connectToChild" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  (arg1)->connectToChild();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_enablePackageInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitDefinition_enablePackageInternal", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_enablePackageInternal" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnitDefinition_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnitDefinition_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UnitDefinition_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnitDefinition_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UnitDefinition_enablePackageInternal" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->enablePackageInternal((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_updateSBMLNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitDefinition_updateSBMLNamespace", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_updateSBMLNamespace" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnitDefinition_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnitDefinition_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UnitDefinition_updateSBMLNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UnitDefinition_updateSBMLNamespace" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  (arg1)->updateSBMLNamespace((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_getTypeCode" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (int)((UnitDefinition const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_getElementName" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (std::string *) &((UnitDefinition const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_simplify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_simplify" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  UnitDefinition::simplify(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_reorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_reorder" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  UnitDefinition::reorder(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_convertToSI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  UnitDefinition *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_convertToSI" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (UnitDefinition *)UnitDefinition::convertToSI((UnitDefinition const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_areIdentical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  UnitDefinition *arg2 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitDefinition_areIdentical", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_areIdentical" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnitDefinition_areIdentical" "', argument " "2"" of type '" "UnitDefinition const *""'"); 
  }
  arg2 = reinterpret_cast< UnitDefinition * >(argp2);
  result = (bool)UnitDefinition::areIdentical((UnitDefinition const *)arg1,(UnitDefinition const *)arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_areEquivalent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  UnitDefinition *arg2 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitDefinition_areEquivalent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_areEquivalent" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnitDefinition_areEquivalent" "', argument " "2"" of type '" "UnitDefinition const *""'"); 
  }
  arg2 = reinterpret_cast< UnitDefinition * >(argp2);
  result = (bool)UnitDefinition::areEquivalent((UnitDefinition const *)arg1,(UnitDefinition const *)arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_combine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  UnitDefinition *arg2 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  UnitDefinition *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitDefinition_combine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_combine" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnitDefinition_combine" "', argument " "2"" of type '" "UnitDefinition *""'"); 
  }
  arg2 = reinterpret_cast< UnitDefinition * >(argp2);
  result = (UnitDefinition *)UnitDefinition::combine(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_divide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  UnitDefinition *arg2 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  UnitDefinition *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnitDefinition_divide", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_divide" "', argument " "1"" of type '" "UnitDefinition *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnitDefinition_divide" "', argument " "2"" of type '" "UnitDefinition *""'"); 
  }
  arg2 = reinterpret_cast< UnitDefinition * >(argp2);
  result = (UnitDefinition *)UnitDefinition::divide(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_printUnits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_printUnits" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnitDefinition_printUnits" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = UnitDefinition::printUnits((UnitDefinition const *)arg1,arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_printUnits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_printUnits" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = UnitDefinition::printUnits((UnitDefinition const *)arg1);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_printUnits(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnitDefinition_printUnits", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UnitDefinition_printUnits__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnitDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UnitDefinition_printUnits__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnitDefinition_printUnits'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UnitDefinition::printUnits(UnitDefinition const *,bool)\n"
    "    UnitDefinition::printUnits(UnitDefinition const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_hasRequiredAttributes" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (bool)((UnitDefinition const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnitDefinition_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  UnitDefinition *arg1 = (UnitDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnitDefinition_hasRequiredElements" "', argument " "1"" of type '" "UnitDefinition const *""'"); 
  }
  arg1 = reinterpret_cast< UnitDefinition * >(argp1);
  result = (bool)((UnitDefinition const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnitDefinition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_UnitDefinition, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UnitDefinition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfUnitDefinitions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfUnitDefinitions *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfUnitDefinitions" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfUnitDefinitions" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfUnitDefinitions *)new ListOfUnitDefinitions(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfUnitDefinitions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfUnitDefinitions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfUnitDefinitions *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfUnitDefinitions" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfUnitDefinitions *)new ListOfUnitDefinitions(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfUnitDefinitions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfUnitDefinitions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfUnitDefinitions", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfUnitDefinitions__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfUnitDefinitions__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfUnitDefinitions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfUnitDefinitions::ListOfUnitDefinitions(unsigned int,unsigned int)\n"
    "    ListOfUnitDefinitions::ListOfUnitDefinitions(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfUnitDefinitions_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfUnitDefinitions *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnitDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnitDefinitions_clone" "', argument " "1"" of type '" "ListOfUnitDefinitions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnitDefinitions * >(argp1);
  result = (ListOfUnitDefinitions *)((ListOfUnitDefinitions const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfUnitDefinitions, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnitDefinitions_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnitDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnitDefinitions_getItemTypeCode" "', argument " "1"" of type '" "ListOfUnitDefinitions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnitDefinitions * >(argp1);
  result = (int)((ListOfUnitDefinitions const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnitDefinitions_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnitDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnitDefinitions_getElementName" "', argument " "1"" of type '" "ListOfUnitDefinitions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnitDefinitions * >(argp1);
  result = (std::string *) &((ListOfUnitDefinitions const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnitDefinitions_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnitDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnitDefinitions_get" "', argument " "1"" of type '" "ListOfUnitDefinitions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnitDefinitions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfUnitDefinitions_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (UnitDefinition *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnitDefinitions_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnitDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnitDefinitions_get" "', argument " "1"" of type '" "ListOfUnitDefinitions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnitDefinitions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfUnitDefinitions_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (UnitDefinition *)((ListOfUnitDefinitions const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnitDefinitions_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnitDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnitDefinitions_get" "', argument " "1"" of type '" "ListOfUnitDefinitions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnitDefinitions * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfUnitDefinitions_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfUnitDefinitions_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (UnitDefinition *)(arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnitDefinitions_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnitDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnitDefinitions_get" "', argument " "1"" of type '" "ListOfUnitDefinitions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnitDefinitions * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfUnitDefinitions_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfUnitDefinitions_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (UnitDefinition *)((ListOfUnitDefinitions const *)arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnitDefinitions_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfUnitDefinitions_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfUnitDefinitions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfUnitDefinitions_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfUnitDefinitions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfUnitDefinitions_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfUnitDefinitions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfUnitDefinitions_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfUnitDefinitions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfUnitDefinitions_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfUnitDefinitions_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfUnitDefinitions::get(unsigned int)\n"
    "    ListOfUnitDefinitions::get(unsigned int) const\n"
    "    ListOfUnitDefinitions::get(std::string const &)\n"
    "    ListOfUnitDefinitions::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfUnitDefinitions_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOfUnitDefinitions_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnitDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnitDefinitions_getElementBySId" "', argument " "1"" of type '" "ListOfUnitDefinitions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnitDefinitions * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfUnitDefinitions_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfUnitDefinitions_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnitDefinitions_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnitDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnitDefinitions_remove" "', argument " "1"" of type '" "ListOfUnitDefinitions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnitDefinitions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfUnitDefinitions_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (UnitDefinition *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnitDefinitions_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnitDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfUnitDefinitions_remove" "', argument " "1"" of type '" "ListOfUnitDefinitions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnitDefinitions * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfUnitDefinitions_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfUnitDefinitions_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (UnitDefinition *)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfUnitDefinitions_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfUnitDefinitions_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfUnitDefinitions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfUnitDefinitions_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfUnitDefinitions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfUnitDefinitions_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfUnitDefinitions_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfUnitDefinitions::remove(unsigned int)\n"
    "    ListOfUnitDefinitions::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListOfUnitDefinitions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfUnitDefinitions *arg1 = (ListOfUnitDefinitions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfUnitDefinitions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfUnitDefinitions" "', argument " "1"" of type '" "ListOfUnitDefinitions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfUnitDefinitions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfUnitDefinitions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfUnitDefinitions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfUnitDefinitions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CompartmentType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CompartmentType" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CompartmentType" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (CompartmentType *)new CompartmentType(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CompartmentType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CompartmentType" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (CompartmentType *)new CompartmentType(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CompartmentType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CompartmentType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompartmentType" "', argument " "1"" of type '" "CompartmentType *""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CompartmentType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_CompartmentType,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CompartmentType" "', argument " "1"" of type '" "CompartmentType const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompartmentType" "', argument " "1"" of type '" "CompartmentType const &""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  {
    try {
      result = (CompartmentType *)new CompartmentType((CompartmentType const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CompartmentType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CompartmentType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CompartmentType__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_CompartmentType, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CompartmentType__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CompartmentType__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CompartmentType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CompartmentType::CompartmentType(unsigned int,unsigned int)\n"
    "    CompartmentType::CompartmentType(SBMLNamespaces *)\n"
    "    CompartmentType::CompartmentType(CompartmentType const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CompartmentType_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CompartmentType *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompartmentType_clone" "', argument " "1"" of type '" "CompartmentType const *""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  result = (CompartmentType *)((CompartmentType const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompartmentType_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompartmentType_getId" "', argument " "1"" of type '" "CompartmentType const *""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  result = (std::string *) &((CompartmentType const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompartmentType_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompartmentType_getName" "', argument " "1"" of type '" "CompartmentType const *""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  result = (std::string *) &((CompartmentType const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompartmentType_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompartmentType_isSetId" "', argument " "1"" of type '" "CompartmentType const *""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  result = (bool)((CompartmentType const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompartmentType_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompartmentType_isSetName" "', argument " "1"" of type '" "CompartmentType const *""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  result = (bool)((CompartmentType const *)arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompartmentType_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "CompartmentType_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompartmentType_setId" "', argument " "1"" of type '" "CompartmentType *""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompartmentType_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CompartmentType_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompartmentType_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "CompartmentType_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompartmentType_setName" "', argument " "1"" of type '" "CompartmentType *""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompartmentType_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CompartmentType_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompartmentType_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompartmentType_unsetName" "', argument " "1"" of type '" "CompartmentType *""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompartmentType_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompartmentType_getTypeCode" "', argument " "1"" of type '" "CompartmentType const *""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  result = (int)((CompartmentType const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompartmentType_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompartmentType_getElementName" "', argument " "1"" of type '" "CompartmentType const *""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  result = (std::string *) &((CompartmentType const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompartmentType_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CompartmentType *arg1 = (CompartmentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompartmentType_hasRequiredAttributes" "', argument " "1"" of type '" "CompartmentType const *""'"); 
  }
  arg1 = reinterpret_cast< CompartmentType * >(argp1);
  result = (bool)((CompartmentType const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CompartmentType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CompartmentType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CompartmentType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfCompartmentTypes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfCompartmentTypes *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfCompartmentTypes" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfCompartmentTypes" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfCompartmentTypes *)new ListOfCompartmentTypes(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfCompartmentTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfCompartmentTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfCompartmentTypes *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfCompartmentTypes" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfCompartmentTypes *)new ListOfCompartmentTypes(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfCompartmentTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfCompartmentTypes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfCompartmentTypes", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfCompartmentTypes__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfCompartmentTypes__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfCompartmentTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfCompartmentTypes::ListOfCompartmentTypes(unsigned int,unsigned int)\n"
    "    ListOfCompartmentTypes::ListOfCompartmentTypes(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfCompartmentTypes_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfCompartmentTypes *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartmentTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartmentTypes_clone" "', argument " "1"" of type '" "ListOfCompartmentTypes const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartmentTypes * >(argp1);
  result = (ListOfCompartmentTypes *)((ListOfCompartmentTypes const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfCompartmentTypes, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartmentTypes_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartmentTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartmentTypes_getItemTypeCode" "', argument " "1"" of type '" "ListOfCompartmentTypes const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartmentTypes * >(argp1);
  result = (int)((ListOfCompartmentTypes const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartmentTypes_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartmentTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartmentTypes_getElementName" "', argument " "1"" of type '" "ListOfCompartmentTypes const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartmentTypes * >(argp1);
  result = (std::string *) &((ListOfCompartmentTypes const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartmentTypes_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartmentTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartmentTypes_get" "', argument " "1"" of type '" "ListOfCompartmentTypes *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartmentTypes * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfCompartmentTypes_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CompartmentType *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartmentTypes_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartmentTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartmentTypes_get" "', argument " "1"" of type '" "ListOfCompartmentTypes const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartmentTypes * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfCompartmentTypes_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CompartmentType *)((ListOfCompartmentTypes const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartmentTypes_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartmentTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartmentTypes_get" "', argument " "1"" of type '" "ListOfCompartmentTypes *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartmentTypes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfCompartmentTypes_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfCompartmentTypes_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (CompartmentType *)(arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartmentTypes_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartmentTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartmentTypes_get" "', argument " "1"" of type '" "ListOfCompartmentTypes const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartmentTypes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfCompartmentTypes_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfCompartmentTypes_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (CompartmentType *)((ListOfCompartmentTypes const *)arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartmentTypes_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfCompartmentTypes_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfCompartmentTypes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfCompartmentTypes_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfCompartmentTypes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfCompartmentTypes_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfCompartmentTypes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfCompartmentTypes_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfCompartmentTypes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfCompartmentTypes_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfCompartmentTypes_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfCompartmentTypes::get(unsigned int)\n"
    "    ListOfCompartmentTypes::get(unsigned int) const\n"
    "    ListOfCompartmentTypes::get(std::string const &)\n"
    "    ListOfCompartmentTypes::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfCompartmentTypes_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartmentTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartmentTypes_remove" "', argument " "1"" of type '" "ListOfCompartmentTypes *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartmentTypes * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfCompartmentTypes_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CompartmentType *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartmentTypes_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  CompartmentType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartmentTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartmentTypes_remove" "', argument " "1"" of type '" "ListOfCompartmentTypes *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartmentTypes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfCompartmentTypes_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfCompartmentTypes_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (CompartmentType *)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CompartmentType, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartmentTypes_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfCompartmentTypes_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfCompartmentTypes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfCompartmentTypes_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfCompartmentTypes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfCompartmentTypes_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfCompartmentTypes_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfCompartmentTypes::remove(unsigned int)\n"
    "    ListOfCompartmentTypes::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListOfCompartmentTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfCompartmentTypes *arg1 = (ListOfCompartmentTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartmentTypes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfCompartmentTypes" "', argument " "1"" of type '" "ListOfCompartmentTypes *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartmentTypes * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfCompartmentTypes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfCompartmentTypes, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfCompartmentTypes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SpeciesType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpeciesType" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpeciesType" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (SpeciesType *)new SpeciesType(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpeciesType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpeciesType" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (SpeciesType *)new SpeciesType(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SpeciesType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpeciesType" "', argument " "1"" of type '" "SpeciesType *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpeciesType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SpeciesType,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpeciesType" "', argument " "1"" of type '" "SpeciesType const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpeciesType" "', argument " "1"" of type '" "SpeciesType const &""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  {
    try {
      result = (SpeciesType *)new SpeciesType((SpeciesType const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpeciesType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SpeciesType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpeciesType__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SpeciesType, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpeciesType__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SpeciesType__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SpeciesType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SpeciesType::SpeciesType(unsigned int,unsigned int)\n"
    "    SpeciesType::SpeciesType(SBMLNamespaces *)\n"
    "    SpeciesType::SpeciesType(SpeciesType const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SpeciesType_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SpeciesType *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesType_clone" "', argument " "1"" of type '" "SpeciesType const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  result = (SpeciesType *)((SpeciesType const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesType_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesType_getId" "', argument " "1"" of type '" "SpeciesType const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  result = (std::string *) &((SpeciesType const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesType_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesType_getName" "', argument " "1"" of type '" "SpeciesType const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  result = (std::string *) &((SpeciesType const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesType_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesType_isSetId" "', argument " "1"" of type '" "SpeciesType const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  result = (bool)((SpeciesType const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesType_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesType_isSetName" "', argument " "1"" of type '" "SpeciesType const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  result = (bool)((SpeciesType const *)arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesType_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SpeciesType_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesType_setId" "', argument " "1"" of type '" "SpeciesType *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpeciesType_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpeciesType_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesType_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SpeciesType_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesType_setName" "', argument " "1"" of type '" "SpeciesType *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpeciesType_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpeciesType_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesType_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesType_unsetName" "', argument " "1"" of type '" "SpeciesType *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesType_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesType_getTypeCode" "', argument " "1"" of type '" "SpeciesType const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  result = (int)((SpeciesType const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesType_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesType_getElementName" "', argument " "1"" of type '" "SpeciesType const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  result = (std::string *) &((SpeciesType const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesType_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesType *arg1 = (SpeciesType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesType_hasRequiredAttributes" "', argument " "1"" of type '" "SpeciesType const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesType * >(argp1);
  result = (bool)((SpeciesType const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SpeciesType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SpeciesType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SpeciesType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfSpeciesTypes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfSpeciesTypes *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfSpeciesTypes" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfSpeciesTypes" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfSpeciesTypes *)new ListOfSpeciesTypes(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfSpeciesTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpeciesTypes *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfSpeciesTypes" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfSpeciesTypes *)new ListOfSpeciesTypes(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfSpeciesTypes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfSpeciesTypes", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfSpeciesTypes__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfSpeciesTypes__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfSpeciesTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfSpeciesTypes::ListOfSpeciesTypes(unsigned int,unsigned int)\n"
    "    ListOfSpeciesTypes::ListOfSpeciesTypes(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesTypes_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfSpeciesTypes *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesTypes_clone" "', argument " "1"" of type '" "ListOfSpeciesTypes const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesTypes * >(argp1);
  result = (ListOfSpeciesTypes *)((ListOfSpeciesTypes const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesTypes, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesTypes_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesTypes_getItemTypeCode" "', argument " "1"" of type '" "ListOfSpeciesTypes const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesTypes * >(argp1);
  result = (int)((ListOfSpeciesTypes const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesTypes_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesTypes_getElementName" "', argument " "1"" of type '" "ListOfSpeciesTypes const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesTypes * >(argp1);
  result = (std::string *) &((ListOfSpeciesTypes const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesTypes_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesTypes_get" "', argument " "1"" of type '" "ListOfSpeciesTypes *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesTypes * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfSpeciesTypes_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SpeciesType *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesTypes_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesTypes_get" "', argument " "1"" of type '" "ListOfSpeciesTypes const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesTypes * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfSpeciesTypes_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SpeciesType *)((ListOfSpeciesTypes const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesTypes_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesTypes_get" "', argument " "1"" of type '" "ListOfSpeciesTypes *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesTypes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfSpeciesTypes_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfSpeciesTypes_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesType *)(arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesTypes_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesTypes_get" "', argument " "1"" of type '" "ListOfSpeciesTypes const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesTypes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfSpeciesTypes_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfSpeciesTypes_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesType *)((ListOfSpeciesTypes const *)arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesTypes_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfSpeciesTypes_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpeciesTypes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfSpeciesTypes_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpeciesTypes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfSpeciesTypes_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpeciesTypes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfSpeciesTypes_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpeciesTypes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfSpeciesTypes_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfSpeciesTypes_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfSpeciesTypes::get(unsigned int)\n"
    "    ListOfSpeciesTypes::get(unsigned int) const\n"
    "    ListOfSpeciesTypes::get(std::string const &)\n"
    "    ListOfSpeciesTypes::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesTypes_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesTypes_remove" "', argument " "1"" of type '" "ListOfSpeciesTypes *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesTypes * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfSpeciesTypes_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SpeciesType *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesTypes_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesType *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesTypes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesTypes_remove" "', argument " "1"" of type '" "ListOfSpeciesTypes *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesTypes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfSpeciesTypes_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfSpeciesTypes_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesType *)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesType, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesTypes_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfSpeciesTypes_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpeciesTypes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfSpeciesTypes_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpeciesTypes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfSpeciesTypes_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfSpeciesTypes_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfSpeciesTypes::remove(unsigned int)\n"
    "    ListOfSpeciesTypes::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListOfSpeciesTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpeciesTypes *arg1 = (ListOfSpeciesTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesTypes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfSpeciesTypes" "', argument " "1"" of type '" "ListOfSpeciesTypes *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesTypes * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfSpeciesTypes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfSpeciesTypes, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfSpeciesTypes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Compartment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Compartment" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Compartment" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Compartment *)new Compartment(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Compartment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Compartment *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Compartment" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (Compartment *)new Compartment(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Compartment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Compartment" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Compartment__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Compartment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Compartment *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Compartment,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Compartment" "', argument " "1"" of type '" "Compartment const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Compartment" "', argument " "1"" of type '" "Compartment const &""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  {
    try {
      result = (Compartment *)new Compartment((Compartment const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Compartment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Compartment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Compartment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Compartment, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Compartment__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Compartment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Compartment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Compartment::Compartment(unsigned int,unsigned int)\n"
    "    Compartment::Compartment(SBMLNamespaces *)\n"
    "    Compartment::Compartment(Compartment const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Compartment_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Compartment *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_clone" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (Compartment *)((Compartment const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_initDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_initDefaults" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  (arg1)->initDefaults();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getId" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (std::string *) &((Compartment const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getName" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (std::string *) &((Compartment const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getCompartmentType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getCompartmentType" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (std::string *) &((Compartment const *)arg1)->getCompartmentType();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getSpatialDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getSpatialDimensions" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (unsigned int)((Compartment const *)arg1)->getSpatialDimensions();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getSpatialDimensionsAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getSpatialDimensionsAsDouble" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (double)((Compartment const *)arg1)->getSpatialDimensionsAsDouble();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getSize" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (double)((Compartment const *)arg1)->getSize();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getVolume" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (double)((Compartment const *)arg1)->getVolume();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getUnits" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (std::string *) &((Compartment const *)arg1)->getUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getOutside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getOutside" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (std::string *) &((Compartment const *)arg1)->getOutside();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getConstant" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (bool)((Compartment const *)arg1)->getConstant();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_isSetId" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (bool)((Compartment const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_isSetName" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (bool)((Compartment const *)arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_isSetCompartmentType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_isSetCompartmentType" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (bool)((Compartment const *)arg1)->isSetCompartmentType();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_isSetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_isSetSize" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (bool)((Compartment const *)arg1)->isSetSize();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_isSetVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_isSetVolume" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (bool)((Compartment const *)arg1)->isSetVolume();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_isSetUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_isSetUnits" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (bool)((Compartment const *)arg1)->isSetUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_isSetOutside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_isSetOutside" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (bool)((Compartment const *)arg1)->isSetOutside();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_isSetSpatialDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_isSetSpatialDimensions" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (bool)((Compartment const *)arg1)->isSetSpatialDimensions();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_isSetConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_isSetConstant" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (bool)((Compartment const *)arg1)->isSetConstant();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Compartment_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_setId" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Compartment_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Compartment_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Compartment_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_setName" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Compartment_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Compartment_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_setCompartmentType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Compartment_setCompartmentType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_setCompartmentType" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Compartment_setCompartmentType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Compartment_setCompartmentType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setCompartmentType((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_setSpatialDimensions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_setSpatialDimensions" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Compartment_setSpatialDimensions" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->setSpatialDimensions(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_setSpatialDimensions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_setSpatialDimensions" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Compartment_setSpatialDimensions" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->setSpatialDimensions(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_setSpatialDimensions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Compartment_setSpatialDimensions", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Compartment, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Compartment_setSpatialDimensions__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Compartment, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Compartment_setSpatialDimensions__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Compartment_setSpatialDimensions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Compartment::setSpatialDimensions(unsigned int)\n"
    "    Compartment::setSpatialDimensions(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Compartment_setSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Compartment_setSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_setSize" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Compartment_setSize" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->setSize(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_setVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Compartment_setVolume", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_setVolume" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Compartment_setVolume" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->setVolume(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_setUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Compartment_setUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_setUnits" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Compartment_setUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Compartment_setUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_setOutside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Compartment_setOutside", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_setOutside" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Compartment_setOutside" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Compartment_setOutside" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setOutside((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_setConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Compartment_setConstant", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_setConstant" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Compartment_setConstant" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setConstant(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Compartment_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_renameSIdRefs" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Compartment_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Compartment_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Compartment_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Compartment_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Compartment_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_renameUnitSIdRefs" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Compartment_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Compartment_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Compartment_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Compartment_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_unsetName" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_unsetCompartmentType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_unsetCompartmentType" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (int)(arg1)->unsetCompartmentType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_unsetConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_unsetConstant" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (int)(arg1)->unsetConstant();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_unsetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_unsetSize" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (int)(arg1)->unsetSize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_unsetVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_unsetVolume" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (int)(arg1)->unsetVolume();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_unsetUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_unsetUnits" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (int)(arg1)->unsetUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_unsetOutside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_unsetOutside" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (int)(arg1)->unsetOutside();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_unsetSpatialDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_unsetSpatialDimensions" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (int)(arg1)->unsetSpatialDimensions();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getDerivedUnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getDerivedUnitDefinition" "', argument " "1"" of type '" "Compartment *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getDerivedUnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getDerivedUnitDefinition" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (UnitDefinition *)((Compartment const *)arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getDerivedUnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Compartment_getDerivedUnitDefinition", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Compartment, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Compartment_getDerivedUnitDefinition__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Compartment, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Compartment_getDerivedUnitDefinition__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Compartment_getDerivedUnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Compartment::getDerivedUnitDefinition()\n"
    "    Compartment::getDerivedUnitDefinition() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Compartment_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getTypeCode" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (int)((Compartment const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_getElementName" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (std::string *) &((Compartment const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compartment_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Compartment *arg1 = (Compartment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Compartment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compartment_hasRequiredAttributes" "', argument " "1"" of type '" "Compartment const *""'"); 
  }
  arg1 = reinterpret_cast< Compartment * >(argp1);
  result = (bool)((Compartment const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Compartment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Compartment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Compartment_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfCompartments__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfCompartments *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfCompartments" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfCompartments" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfCompartments *)new ListOfCompartments(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfCompartments, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfCompartments__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfCompartments *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfCompartments" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfCompartments *)new ListOfCompartments(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfCompartments, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfCompartments(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfCompartments", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfCompartments__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfCompartments__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfCompartments'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfCompartments::ListOfCompartments(unsigned int,unsigned int)\n"
    "    ListOfCompartments::ListOfCompartments(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfCompartments_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfCompartments *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartments_clone" "', argument " "1"" of type '" "ListOfCompartments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartments * >(argp1);
  result = (ListOfCompartments *)((ListOfCompartments const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfCompartments, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartments_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartments_getItemTypeCode" "', argument " "1"" of type '" "ListOfCompartments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartments * >(argp1);
  result = (int)((ListOfCompartments const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartments_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartments_getElementName" "', argument " "1"" of type '" "ListOfCompartments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartments * >(argp1);
  result = (std::string *) &((ListOfCompartments const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartments_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartments_get" "', argument " "1"" of type '" "ListOfCompartments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartments * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfCompartments_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Compartment *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartments_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartments_get" "', argument " "1"" of type '" "ListOfCompartments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartments * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfCompartments_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Compartment *)((ListOfCompartments const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartments_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartments_get" "', argument " "1"" of type '" "ListOfCompartments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartments * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfCompartments_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfCompartments_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Compartment *)(arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartments_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartments_get" "', argument " "1"" of type '" "ListOfCompartments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartments * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfCompartments_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfCompartments_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Compartment *)((ListOfCompartments const *)arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartments_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfCompartments_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfCompartments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfCompartments_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfCompartments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfCompartments_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfCompartments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfCompartments_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfCompartments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfCompartments_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfCompartments_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfCompartments::get(unsigned int)\n"
    "    ListOfCompartments::get(unsigned int) const\n"
    "    ListOfCompartments::get(std::string const &)\n"
    "    ListOfCompartments::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfCompartments_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartments_remove" "', argument " "1"" of type '" "ListOfCompartments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartments * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfCompartments_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Compartment *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartments_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Compartment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfCompartments_remove" "', argument " "1"" of type '" "ListOfCompartments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartments * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfCompartments_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfCompartments_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Compartment *)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Compartment, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfCompartments_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfCompartments_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfCompartments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfCompartments_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfCompartments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfCompartments_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfCompartments_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfCompartments::remove(unsigned int)\n"
    "    ListOfCompartments::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListOfCompartments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfCompartments *arg1 = (ListOfCompartments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfCompartments, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfCompartments" "', argument " "1"" of type '" "ListOfCompartments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfCompartments * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfCompartments_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfCompartments, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfCompartments_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Species__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Species" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Species" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Species *)new Species(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Species__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Species *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Species" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (Species *)new Species(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Species(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Species" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Species__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Species *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Species *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Species,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Species" "', argument " "1"" of type '" "Species const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Species" "', argument " "1"" of type '" "Species const &""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  {
    try {
      result = (Species *)new Species((Species const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Species(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Species", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Species__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Species, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Species__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Species__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Species'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Species::Species(unsigned int,unsigned int)\n"
    "    Species::Species(SBMLNamespaces *)\n"
    "    Species::Species(Species const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Species_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Species *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_clone" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (Species *)((Species const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_initDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_initDefaults" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  (arg1)->initDefaults();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getId" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (std::string *) &((Species const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getName" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (std::string *) &((Species const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getSpeciesType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getSpeciesType" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (std::string *) &((Species const *)arg1)->getSpeciesType();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getCompartment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getCompartment" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (std::string *) &((Species const *)arg1)->getCompartment();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getInitialAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getInitialAmount" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (double)((Species const *)arg1)->getInitialAmount();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getInitialConcentration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getInitialConcentration" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (double)((Species const *)arg1)->getInitialConcentration();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getSubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getSubstanceUnits" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (std::string *) &((Species const *)arg1)->getSubstanceUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getSpatialSizeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getSpatialSizeUnits" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (std::string *) &((Species const *)arg1)->getSpatialSizeUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getUnits" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (std::string *) &((Species const *)arg1)->getUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getHasOnlySubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getHasOnlySubstanceUnits" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->getHasOnlySubstanceUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getBoundaryCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getBoundaryCondition" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->getBoundaryCondition();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getCharge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getCharge" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)((Species const *)arg1)->getCharge();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getConstant" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->getConstant();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getConversionFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getConversionFactor" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (std::string *) &((Species const *)arg1)->getConversionFactor();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetId" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetName" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetSpeciesType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetSpeciesType" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetSpeciesType();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetCompartment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetCompartment" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetCompartment();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetInitialAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetInitialAmount" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetInitialAmount();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetInitialConcentration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetInitialConcentration" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetInitialConcentration();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetSubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetSubstanceUnits" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetSubstanceUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetSpatialSizeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetSpatialSizeUnits" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetSpatialSizeUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetUnits" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetCharge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetCharge" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetCharge();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetConversionFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetConversionFactor" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetConversionFactor();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetBoundaryCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetBoundaryCondition" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetBoundaryCondition();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetHasOnlySubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetHasOnlySubstanceUnits" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetHasOnlySubstanceUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_isSetConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_isSetConstant" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->isSetConstant();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setId" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Species_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Species_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setName" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Species_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Species_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setSpeciesType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setSpeciesType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setSpeciesType" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Species_setSpeciesType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Species_setSpeciesType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setSpeciesType((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setCompartment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setCompartment", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setCompartment" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Species_setCompartment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Species_setCompartment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setCompartment((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setInitialAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setInitialAmount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setInitialAmount" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Species_setInitialAmount" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->setInitialAmount(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setInitialConcentration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setInitialConcentration", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setInitialConcentration" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Species_setInitialConcentration" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->setInitialConcentration(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setSubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setSubstanceUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setSubstanceUnits" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Species_setSubstanceUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Species_setSubstanceUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setSubstanceUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setSpatialSizeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setSpatialSizeUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setSpatialSizeUnits" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Species_setSpatialSizeUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Species_setSpatialSizeUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setSpatialSizeUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setUnits" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Species_setUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Species_setUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setHasOnlySubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setHasOnlySubstanceUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setHasOnlySubstanceUnits" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Species_setHasOnlySubstanceUnits" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setHasOnlySubstanceUnits(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setBoundaryCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setBoundaryCondition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setBoundaryCondition" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Species_setBoundaryCondition" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setBoundaryCondition(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setCharge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setCharge", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setCharge" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Species_setCharge" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->setCharge(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setConstant", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setConstant" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Species_setConstant" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setConstant(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_setConversionFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_setConversionFactor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_setConversionFactor" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Species_setConversionFactor" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Species_setConversionFactor" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setConversionFactor((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetName" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetConstant" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetConstant();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetSpeciesType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetSpeciesType" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetSpeciesType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetInitialAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetInitialAmount" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetInitialAmount();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetInitialConcentration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetInitialConcentration" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetInitialConcentration();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetSubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetSubstanceUnits" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetSubstanceUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetSpatialSizeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetSpatialSizeUnits" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetSpatialSizeUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetUnits" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetCharge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetCharge" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetCharge();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetConversionFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetConversionFactor" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetConversionFactor();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetCompartment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetCompartment" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetCompartment();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetBoundaryCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetBoundaryCondition" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetBoundaryCondition();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_unsetHasOnlySubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_unsetHasOnlySubstanceUnits" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)(arg1)->unsetHasOnlySubstanceUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getDerivedUnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getDerivedUnitDefinition" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getDerivedUnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getDerivedUnitDefinition" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (UnitDefinition *)((Species const *)arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getDerivedUnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Species_getDerivedUnitDefinition", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Species, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Species_getDerivedUnitDefinition__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Species, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Species_getDerivedUnitDefinition__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Species_getDerivedUnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Species::getDerivedUnitDefinition()\n"
    "    Species::getDerivedUnitDefinition() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Species_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getTypeCode" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (int)((Species const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_getElementName" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (std::string *) &((Species const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_hasRequiredAttributes" "', argument " "1"" of type '" "Species const *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  result = (bool)((Species const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_renameSIdRefs" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Species_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Species_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Species_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Species_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Species_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Species *arg1 = (Species *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Species_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Species_renameUnitSIdRefs" "', argument " "1"" of type '" "Species *""'"); 
  }
  arg1 = reinterpret_cast< Species * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Species_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Species_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Species_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Species_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *Species_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Species, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Species_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfSpecies__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfSpecies *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfSpecies" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfSpecies" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfSpecies *)new ListOfSpecies(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpecies, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfSpecies__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpecies *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfSpecies" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfSpecies *)new ListOfSpecies(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpecies, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfSpecies(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfSpecies", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfSpecies__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfSpecies__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfSpecies'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfSpecies::ListOfSpecies(unsigned int,unsigned int)\n"
    "    ListOfSpecies::ListOfSpecies(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfSpecies_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfSpecies *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpecies, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpecies_clone" "', argument " "1"" of type '" "ListOfSpecies const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpecies * >(argp1);
  result = (ListOfSpecies *)((ListOfSpecies const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpecies, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpecies_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpecies, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpecies_getItemTypeCode" "', argument " "1"" of type '" "ListOfSpecies const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpecies * >(argp1);
  result = (int)((ListOfSpecies const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpecies_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpecies, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpecies_getElementName" "', argument " "1"" of type '" "ListOfSpecies const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpecies * >(argp1);
  result = (std::string *) &((ListOfSpecies const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpecies_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpecies, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpecies_get" "', argument " "1"" of type '" "ListOfSpecies *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpecies * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfSpecies_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Species *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpecies_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpecies, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpecies_get" "', argument " "1"" of type '" "ListOfSpecies const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpecies * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfSpecies_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Species *)((ListOfSpecies const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpecies_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpecies, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpecies_get" "', argument " "1"" of type '" "ListOfSpecies *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpecies * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfSpecies_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfSpecies_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Species *)(arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpecies_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpecies, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpecies_get" "', argument " "1"" of type '" "ListOfSpecies const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpecies * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfSpecies_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfSpecies_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Species *)((ListOfSpecies const *)arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpecies_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfSpecies_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpecies, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfSpecies_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpecies, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfSpecies_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpecies, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfSpecies_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpecies, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfSpecies_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfSpecies_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfSpecies::get(unsigned int)\n"
    "    ListOfSpecies::get(unsigned int) const\n"
    "    ListOfSpecies::get(std::string const &)\n"
    "    ListOfSpecies::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfSpecies_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpecies, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpecies_remove" "', argument " "1"" of type '" "ListOfSpecies *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpecies * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfSpecies_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Species *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpecies_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Species *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpecies, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpecies_remove" "', argument " "1"" of type '" "ListOfSpecies *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpecies * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfSpecies_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfSpecies_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Species *)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Species, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpecies_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfSpecies_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpecies, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfSpecies_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpecies, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfSpecies_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfSpecies_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfSpecies::remove(unsigned int)\n"
    "    ListOfSpecies::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListOfSpecies(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpecies *arg1 = (ListOfSpecies *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpecies, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfSpecies" "', argument " "1"" of type '" "ListOfSpecies *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpecies * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfSpecies_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfSpecies, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfSpecies_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Parameter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Parameter" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Parameter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Parameter *)new Parameter(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Parameter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Parameter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Parameter" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (Parameter *)new Parameter(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Parameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Parameter" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Parameter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Parameter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Parameter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Parameter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Parameter" "', argument " "1"" of type '" "Parameter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Parameter" "', argument " "1"" of type '" "Parameter const &""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  {
    try {
      result = (Parameter *)new Parameter((Parameter const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Parameter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Parameter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Parameter__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Parameter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Parameter__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Parameter__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Parameter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Parameter::Parameter(unsigned int,unsigned int)\n"
    "    Parameter::Parameter(SBMLNamespaces *)\n"
    "    Parameter::Parameter(Parameter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Parameter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Parameter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_clone" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (Parameter *)((Parameter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_initDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_initDefaults" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  (arg1)->initDefaults();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_getId" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (std::string *) &((Parameter const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_getName" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (std::string *) &((Parameter const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_getValue" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (double)((Parameter const *)arg1)->getValue();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_getUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_getUnits" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (std::string *) &((Parameter const *)arg1)->getUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_getConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_getConstant" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (bool)((Parameter const *)arg1)->getConstant();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_isSetId" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (bool)((Parameter const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_isSetName" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (bool)((Parameter const *)arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_isSetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_isSetValue" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (bool)((Parameter const *)arg1)->isSetValue();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_isSetUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_isSetUnits" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (bool)((Parameter const *)arg1)->isSetUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_isSetConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_isSetConstant" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (bool)((Parameter const *)arg1)->isSetConstant();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Parameter_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_setId" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Parameter_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Parameter_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Parameter_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_setName" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Parameter_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Parameter_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Parameter_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_setValue" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parameter_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->setValue(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_setUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Parameter_setUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_setUnits" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Parameter_setUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Parameter_setUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_setConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Parameter_setConstant", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_setConstant" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parameter_setConstant" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setConstant(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_unsetName" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_unsetConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_unsetConstant" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (int)(arg1)->unsetConstant();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_unsetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_unsetValue" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (int)(arg1)->unsetValue();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_unsetUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_unsetUnits" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (int)(arg1)->unsetUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_getDerivedUnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_getDerivedUnitDefinition" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_getDerivedUnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_getDerivedUnitDefinition" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (UnitDefinition *)((Parameter const *)arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_getDerivedUnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Parameter_getDerivedUnitDefinition", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Parameter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Parameter_getDerivedUnitDefinition__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Parameter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Parameter_getDerivedUnitDefinition__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Parameter_getDerivedUnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Parameter::getDerivedUnitDefinition()\n"
    "    Parameter::getDerivedUnitDefinition() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Parameter_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_getTypeCode" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (int)((Parameter const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_getElementName" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (std::string *) &((Parameter const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_hasRequiredAttributes" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  result = (bool)((Parameter const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Parameter_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_renameUnitSIdRefs" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Parameter_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Parameter_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Parameter_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Parameter_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_setCalculatingUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Parameter_setCalculatingUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_setCalculatingUnits" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parameter_setCalculatingUnits" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCalculatingUnits(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Parameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Parameter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Parameter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfParameters *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfParameters" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfParameters" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfParameters *)new ListOfParameters(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfParameters, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfParameters *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfParameters" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfParameters *)new ListOfParameters(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfParameters, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfParameters(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfParameters", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfParameters__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfParameters__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfParameters'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfParameters::ListOfParameters(unsigned int,unsigned int)\n"
    "    ListOfParameters::ListOfParameters(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfParameters_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfParameters *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfParameters_clone" "', argument " "1"" of type '" "ListOfParameters const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfParameters * >(argp1);
  result = (ListOfParameters *)((ListOfParameters const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfParameters, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfParameters_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfParameters_getItemTypeCode" "', argument " "1"" of type '" "ListOfParameters const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfParameters * >(argp1);
  result = (int)((ListOfParameters const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfParameters_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfParameters_getElementName" "', argument " "1"" of type '" "ListOfParameters const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfParameters * >(argp1);
  result = (std::string *) &((ListOfParameters const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfParameters_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfParameters_get" "', argument " "1"" of type '" "ListOfParameters *""'"); 
  }
  arg1 = reinterpret_cast< ListOfParameters * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfParameters_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Parameter *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfParameters_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfParameters_get" "', argument " "1"" of type '" "ListOfParameters const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfParameters * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfParameters_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Parameter *)((ListOfParameters const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfParameters_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfParameters_get" "', argument " "1"" of type '" "ListOfParameters *""'"); 
  }
  arg1 = reinterpret_cast< ListOfParameters * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfParameters_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfParameters_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Parameter *)(arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfParameters_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfParameters_get" "', argument " "1"" of type '" "ListOfParameters const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfParameters * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfParameters_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfParameters_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Parameter *)((ListOfParameters const *)arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfParameters_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfParameters_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfParameters_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfParameters_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfParameters_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfParameters_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfParameters_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfParameters::get(unsigned int)\n"
    "    ListOfParameters::get(unsigned int) const\n"
    "    ListOfParameters::get(std::string const &)\n"
    "    ListOfParameters::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfParameters_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfParameters_remove" "', argument " "1"" of type '" "ListOfParameters *""'"); 
  }
  arg1 = reinterpret_cast< ListOfParameters * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfParameters_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Parameter *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfParameters_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfParameters_remove" "', argument " "1"" of type '" "ListOfParameters *""'"); 
  }
  arg1 = reinterpret_cast< ListOfParameters * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfParameters_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfParameters_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Parameter *)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfParameters_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfParameters_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfParameters_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfParameters_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfParameters_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfParameters::remove(unsigned int)\n"
    "    ListOfParameters::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListOfParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfParameters *arg1 = (ListOfParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfParameters, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfParameters" "', argument " "1"" of type '" "ListOfParameters *""'"); 
  }
  arg1 = reinterpret_cast< ListOfParameters * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfParameters, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfParameters_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LocalParameter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalParameter" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalParameter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (LocalParameter *)new LocalParameter(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalParameter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalParameter" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (LocalParameter *)new LocalParameter(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LocalParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  LocalParameter *arg1 = (LocalParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LocalParameter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalParameter" "', argument " "1"" of type '" "LocalParameter *""'"); 
  }
  arg1 = reinterpret_cast< LocalParameter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalParameter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LocalParameter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_LocalParameter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalParameter" "', argument " "1"" of type '" "LocalParameter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalParameter" "', argument " "1"" of type '" "LocalParameter const &""'"); 
  }
  arg1 = reinterpret_cast< LocalParameter * >(argp1);
  {
    try {
      result = (LocalParameter *)new LocalParameter((LocalParameter const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalParameter__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Parameter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Parameter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalParameter" "', argument " "1"" of type '" "Parameter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalParameter" "', argument " "1"" of type '" "Parameter const &""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  {
    try {
      result = (LocalParameter *)new LocalParameter((Parameter const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalParameter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LocalParameter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocalParameter__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_LocalParameter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocalParameter__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Parameter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocalParameter__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LocalParameter__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LocalParameter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LocalParameter::LocalParameter(unsigned int,unsigned int)\n"
    "    LocalParameter::LocalParameter(SBMLNamespaces *)\n"
    "    LocalParameter::LocalParameter(LocalParameter const &)\n"
    "    LocalParameter::LocalParameter(Parameter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LocalParameter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  LocalParameter *arg1 = (LocalParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  LocalParameter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalParameter_clone" "', argument " "1"" of type '" "LocalParameter const *""'"); 
  }
  arg1 = reinterpret_cast< LocalParameter * >(argp1);
  result = (LocalParameter *)((LocalParameter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalParameter_getDerivedUnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LocalParameter *arg1 = (LocalParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalParameter_getDerivedUnitDefinition" "', argument " "1"" of type '" "LocalParameter *""'"); 
  }
  arg1 = reinterpret_cast< LocalParameter * >(argp1);
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalParameter_getDerivedUnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LocalParameter *arg1 = (LocalParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalParameter_getDerivedUnitDefinition" "', argument " "1"" of type '" "LocalParameter const *""'"); 
  }
  arg1 = reinterpret_cast< LocalParameter * >(argp1);
  result = (UnitDefinition *)((LocalParameter const *)arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalParameter_getDerivedUnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LocalParameter_getDerivedUnitDefinition", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LocalParameter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LocalParameter_getDerivedUnitDefinition__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LocalParameter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LocalParameter_getDerivedUnitDefinition__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LocalParameter_getDerivedUnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LocalParameter::getDerivedUnitDefinition()\n"
    "    LocalParameter::getDerivedUnitDefinition() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LocalParameter_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  LocalParameter *arg1 = (LocalParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalParameter_getTypeCode" "', argument " "1"" of type '" "LocalParameter const *""'"); 
  }
  arg1 = reinterpret_cast< LocalParameter * >(argp1);
  result = (int)((LocalParameter const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalParameter_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  LocalParameter *arg1 = (LocalParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalParameter_getElementName" "', argument " "1"" of type '" "LocalParameter const *""'"); 
  }
  arg1 = reinterpret_cast< LocalParameter * >(argp1);
  result = (std::string *) &((LocalParameter const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalParameter_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  LocalParameter *arg1 = (LocalParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalParameter_hasRequiredAttributes" "', argument " "1"" of type '" "LocalParameter const *""'"); 
  }
  arg1 = reinterpret_cast< LocalParameter * >(argp1);
  result = (bool)((LocalParameter const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalParameter_getConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  LocalParameter *arg1 = (LocalParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalParameter_getConstant" "', argument " "1"" of type '" "LocalParameter const *""'"); 
  }
  arg1 = reinterpret_cast< LocalParameter * >(argp1);
  result = (bool)((LocalParameter const *)arg1)->getConstant();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalParameter_isSetConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  LocalParameter *arg1 = (LocalParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalParameter_isSetConstant" "', argument " "1"" of type '" "LocalParameter const *""'"); 
  }
  arg1 = reinterpret_cast< LocalParameter * >(argp1);
  result = (bool)((LocalParameter const *)arg1)->isSetConstant();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalParameter_setConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  LocalParameter *arg1 = (LocalParameter *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "LocalParameter_setConstant", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalParameter_setConstant" "', argument " "1"" of type '" "LocalParameter *""'"); 
  }
  arg1 = reinterpret_cast< LocalParameter * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LocalParameter_setConstant" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setConstant(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalParameter_unsetConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  LocalParameter *arg1 = (LocalParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalParameter_unsetConstant" "', argument " "1"" of type '" "LocalParameter *""'"); 
  }
  arg1 = reinterpret_cast< LocalParameter * >(argp1);
  result = (int)(arg1)->unsetConstant();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LocalParameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_LocalParameter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LocalParameter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfLocalParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfLocalParameters *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfLocalParameters" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfLocalParameters" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfLocalParameters *)new ListOfLocalParameters(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfLocalParameters, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfLocalParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfLocalParameters *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfLocalParameters" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfLocalParameters *)new ListOfLocalParameters(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfLocalParameters, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfLocalParameters(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfLocalParameters", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfLocalParameters__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfLocalParameters__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfLocalParameters'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfLocalParameters::ListOfLocalParameters(unsigned int,unsigned int)\n"
    "    ListOfLocalParameters::ListOfLocalParameters(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfLocalParameters_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfLocalParameters *arg1 = (ListOfLocalParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfLocalParameters *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfLocalParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfLocalParameters_clone" "', argument " "1"" of type '" "ListOfLocalParameters const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfLocalParameters * >(argp1);
  result = (ListOfLocalParameters *)((ListOfLocalParameters const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfLocalParameters, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfLocalParameters_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfLocalParameters *arg1 = (ListOfLocalParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfLocalParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfLocalParameters_getItemTypeCode" "', argument " "1"" of type '" "ListOfLocalParameters const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfLocalParameters * >(argp1);
  result = (int)((ListOfLocalParameters const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfLocalParameters_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfLocalParameters *arg1 = (ListOfLocalParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfLocalParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfLocalParameters_getElementName" "', argument " "1"" of type '" "ListOfLocalParameters const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfLocalParameters * >(argp1);
  result = (std::string *) &((ListOfLocalParameters const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfLocalParameters_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfLocalParameters *arg1 = (ListOfLocalParameters *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfLocalParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfLocalParameters_get" "', argument " "1"" of type '" "ListOfLocalParameters *""'"); 
  }
  arg1 = reinterpret_cast< ListOfLocalParameters * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfLocalParameters_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (LocalParameter *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfLocalParameters_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfLocalParameters *arg1 = (ListOfLocalParameters *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfLocalParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfLocalParameters_get" "', argument " "1"" of type '" "ListOfLocalParameters const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfLocalParameters * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfLocalParameters_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (LocalParameter *)((ListOfLocalParameters const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfLocalParameters_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfLocalParameters *arg1 = (ListOfLocalParameters *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfLocalParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfLocalParameters_get" "', argument " "1"" of type '" "ListOfLocalParameters *""'"); 
  }
  arg1 = reinterpret_cast< ListOfLocalParameters * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfLocalParameters_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfLocalParameters_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (LocalParameter *)(arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfLocalParameters_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfLocalParameters *arg1 = (ListOfLocalParameters *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfLocalParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfLocalParameters_get" "', argument " "1"" of type '" "ListOfLocalParameters const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfLocalParameters * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfLocalParameters_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfLocalParameters_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (LocalParameter *)((ListOfLocalParameters const *)arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfLocalParameters_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfLocalParameters_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfLocalParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfLocalParameters_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfLocalParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfLocalParameters_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfLocalParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfLocalParameters_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfLocalParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfLocalParameters_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfLocalParameters_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfLocalParameters::get(unsigned int)\n"
    "    ListOfLocalParameters::get(unsigned int) const\n"
    "    ListOfLocalParameters::get(std::string const &)\n"
    "    ListOfLocalParameters::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfLocalParameters_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfLocalParameters *arg1 = (ListOfLocalParameters *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOfLocalParameters_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfLocalParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfLocalParameters_getElementBySId" "', argument " "1"" of type '" "ListOfLocalParameters *""'"); 
  }
  arg1 = reinterpret_cast< ListOfLocalParameters * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfLocalParameters_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfLocalParameters_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfLocalParameters_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfLocalParameters *arg1 = (ListOfLocalParameters *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfLocalParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfLocalParameters_remove" "', argument " "1"" of type '" "ListOfLocalParameters *""'"); 
  }
  arg1 = reinterpret_cast< ListOfLocalParameters * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfLocalParameters_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (LocalParameter *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfLocalParameters_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfLocalParameters *arg1 = (ListOfLocalParameters *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfLocalParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfLocalParameters_remove" "', argument " "1"" of type '" "ListOfLocalParameters *""'"); 
  }
  arg1 = reinterpret_cast< ListOfLocalParameters * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfLocalParameters_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfLocalParameters_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (LocalParameter *)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfLocalParameters_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfLocalParameters_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfLocalParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfLocalParameters_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfLocalParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfLocalParameters_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfLocalParameters_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfLocalParameters::remove(unsigned int)\n"
    "    ListOfLocalParameters::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListOfLocalParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfLocalParameters *arg1 = (ListOfLocalParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfLocalParameters, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfLocalParameters" "', argument " "1"" of type '" "ListOfLocalParameters *""'"); 
  }
  arg1 = reinterpret_cast< ListOfLocalParameters * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfLocalParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfLocalParameters, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfLocalParameters_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InitialAssignment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitialAssignment" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InitialAssignment" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (InitialAssignment *)new InitialAssignment(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InitialAssignment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InitialAssignment" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (InitialAssignment *)new InitialAssignment(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InitialAssignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InitialAssignment" "', argument " "1"" of type '" "InitialAssignment *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InitialAssignment__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_InitialAssignment,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InitialAssignment" "', argument " "1"" of type '" "InitialAssignment const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InitialAssignment" "', argument " "1"" of type '" "InitialAssignment const &""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  {
    try {
      result = (InitialAssignment *)new InitialAssignment((InitialAssignment const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InitialAssignment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InitialAssignment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InitialAssignment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_InitialAssignment, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InitialAssignment__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_InitialAssignment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InitialAssignment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InitialAssignment::InitialAssignment(unsigned int,unsigned int)\n"
    "    InitialAssignment::InitialAssignment(SBMLNamespaces *)\n"
    "    InitialAssignment::InitialAssignment(InitialAssignment const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  InitialAssignment *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_clone" "', argument " "1"" of type '" "InitialAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (InitialAssignment *)((InitialAssignment const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_getSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_getSymbol" "', argument " "1"" of type '" "InitialAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (std::string *) &((InitialAssignment const *)arg1)->getSymbol();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_getMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_getMath" "', argument " "1"" of type '" "InitialAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (ASTNode *)((InitialAssignment const *)arg1)->getMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_isSetSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_isSetSymbol" "', argument " "1"" of type '" "InitialAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (bool)((InitialAssignment const *)arg1)->isSetSymbol();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_isSetMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_isSetMath" "', argument " "1"" of type '" "InitialAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (bool)((InitialAssignment const *)arg1)->isSetMath();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_setSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "InitialAssignment_setSymbol", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_setSymbol" "', argument " "1"" of type '" "InitialAssignment *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InitialAssignment_setSymbol" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InitialAssignment_setSymbol" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setSymbol((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_unsetSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_unsetSymbol" "', argument " "1"" of type '" "InitialAssignment *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (int)(arg1)->unsetSymbol();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_setMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "InitialAssignment_setMath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_setMath" "', argument " "1"" of type '" "InitialAssignment *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InitialAssignment_setMath" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (int)(arg1)->setMath((ASTNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_getDerivedUnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_getDerivedUnitDefinition" "', argument " "1"" of type '" "InitialAssignment *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_getDerivedUnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_getDerivedUnitDefinition" "', argument " "1"" of type '" "InitialAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (UnitDefinition *)((InitialAssignment const *)arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_getDerivedUnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InitialAssignment_getDerivedUnitDefinition", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InitialAssignment, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_InitialAssignment_getDerivedUnitDefinition__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InitialAssignment, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_InitialAssignment_getDerivedUnitDefinition__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InitialAssignment_getDerivedUnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InitialAssignment::getDerivedUnitDefinition()\n"
    "    InitialAssignment::getDerivedUnitDefinition() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_containsUndeclaredUnits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_containsUndeclaredUnits" "', argument " "1"" of type '" "InitialAssignment *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (bool)(arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_containsUndeclaredUnits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_containsUndeclaredUnits" "', argument " "1"" of type '" "InitialAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (bool)((InitialAssignment const *)arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_containsUndeclaredUnits(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InitialAssignment_containsUndeclaredUnits", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InitialAssignment, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_InitialAssignment_containsUndeclaredUnits__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InitialAssignment, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_InitialAssignment_containsUndeclaredUnits__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InitialAssignment_containsUndeclaredUnits'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InitialAssignment::containsUndeclaredUnits()\n"
    "    InitialAssignment::containsUndeclaredUnits() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_getTypeCode" "', argument " "1"" of type '" "InitialAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (int)((InitialAssignment const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_getElementName" "', argument " "1"" of type '" "InitialAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (std::string *) &((InitialAssignment const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_hasRequiredAttributes" "', argument " "1"" of type '" "InitialAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (bool)((InitialAssignment const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_hasRequiredElements" "', argument " "1"" of type '" "InitialAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (bool)((InitialAssignment const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_getId" "', argument " "1"" of type '" "InitialAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  result = (std::string *) &((InitialAssignment const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InitialAssignment_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_renameSIdRefs" "', argument " "1"" of type '" "InitialAssignment *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InitialAssignment_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InitialAssignment_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InitialAssignment_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InitialAssignment_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InitialAssignment_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_renameUnitSIdRefs" "', argument " "1"" of type '" "InitialAssignment *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InitialAssignment_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InitialAssignment_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InitialAssignment_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InitialAssignment_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_replaceSIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InitialAssignment_replaceSIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_replaceSIDWithFunction" "', argument " "1"" of type '" "InitialAssignment *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InitialAssignment_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InitialAssignment_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InitialAssignment_replaceSIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceSIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_divideAssignmentsToSIdByFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InitialAssignment_divideAssignmentsToSIdByFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_divideAssignmentsToSIdByFunction" "', argument " "1"" of type '" "InitialAssignment *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InitialAssignment_divideAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InitialAssignment_divideAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InitialAssignment_divideAssignmentsToSIdByFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->divideAssignmentsToSIdByFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InitialAssignment_multiplyAssignmentsToSIdByFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  InitialAssignment *arg1 = (InitialAssignment *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InitialAssignment_multiplyAssignmentsToSIdByFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitialAssignment_multiplyAssignmentsToSIdByFunction" "', argument " "1"" of type '" "InitialAssignment *""'"); 
  }
  arg1 = reinterpret_cast< InitialAssignment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InitialAssignment_multiplyAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InitialAssignment_multiplyAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InitialAssignment_multiplyAssignmentsToSIdByFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->multiplyAssignmentsToSIdByFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *InitialAssignment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InitialAssignment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InitialAssignment_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfInitialAssignments__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfInitialAssignments *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfInitialAssignments" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfInitialAssignments" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfInitialAssignments *)new ListOfInitialAssignments(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfInitialAssignments, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfInitialAssignments__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfInitialAssignments *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfInitialAssignments" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfInitialAssignments *)new ListOfInitialAssignments(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfInitialAssignments, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfInitialAssignments(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfInitialAssignments", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfInitialAssignments__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfInitialAssignments__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfInitialAssignments'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfInitialAssignments::ListOfInitialAssignments(unsigned int,unsigned int)\n"
    "    ListOfInitialAssignments::ListOfInitialAssignments(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfInitialAssignments_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfInitialAssignments *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfInitialAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfInitialAssignments_clone" "', argument " "1"" of type '" "ListOfInitialAssignments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfInitialAssignments * >(argp1);
  result = (ListOfInitialAssignments *)((ListOfInitialAssignments const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfInitialAssignments, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfInitialAssignments_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfInitialAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfInitialAssignments_getItemTypeCode" "', argument " "1"" of type '" "ListOfInitialAssignments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfInitialAssignments * >(argp1);
  result = (int)((ListOfInitialAssignments const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfInitialAssignments_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfInitialAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfInitialAssignments_getElementName" "', argument " "1"" of type '" "ListOfInitialAssignments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfInitialAssignments * >(argp1);
  result = (std::string *) &((ListOfInitialAssignments const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfInitialAssignments_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfInitialAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfInitialAssignments_get" "', argument " "1"" of type '" "ListOfInitialAssignments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfInitialAssignments * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfInitialAssignments_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (InitialAssignment *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfInitialAssignments_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfInitialAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfInitialAssignments_get" "', argument " "1"" of type '" "ListOfInitialAssignments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfInitialAssignments * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfInitialAssignments_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (InitialAssignment *)((ListOfInitialAssignments const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfInitialAssignments_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfInitialAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfInitialAssignments_get" "', argument " "1"" of type '" "ListOfInitialAssignments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfInitialAssignments * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfInitialAssignments_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfInitialAssignments_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (InitialAssignment *)(arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfInitialAssignments_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfInitialAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfInitialAssignments_get" "', argument " "1"" of type '" "ListOfInitialAssignments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfInitialAssignments * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfInitialAssignments_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfInitialAssignments_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (InitialAssignment *)((ListOfInitialAssignments const *)arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfInitialAssignments_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfInitialAssignments_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfInitialAssignments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfInitialAssignments_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfInitialAssignments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfInitialAssignments_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfInitialAssignments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfInitialAssignments_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfInitialAssignments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfInitialAssignments_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfInitialAssignments_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfInitialAssignments::get(unsigned int)\n"
    "    ListOfInitialAssignments::get(unsigned int) const\n"
    "    ListOfInitialAssignments::get(std::string const &)\n"
    "    ListOfInitialAssignments::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfInitialAssignments_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfInitialAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfInitialAssignments_remove" "', argument " "1"" of type '" "ListOfInitialAssignments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfInitialAssignments * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfInitialAssignments_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (InitialAssignment *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfInitialAssignments_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  InitialAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfInitialAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfInitialAssignments_remove" "', argument " "1"" of type '" "ListOfInitialAssignments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfInitialAssignments * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfInitialAssignments_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfInitialAssignments_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (InitialAssignment *)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InitialAssignment, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfInitialAssignments_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfInitialAssignments_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfInitialAssignments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfInitialAssignments_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfInitialAssignments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfInitialAssignments_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfInitialAssignments_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfInitialAssignments::remove(unsigned int)\n"
    "    ListOfInitialAssignments::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfInitialAssignments_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOfInitialAssignments_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfInitialAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfInitialAssignments_getElementBySId" "', argument " "1"" of type '" "ListOfInitialAssignments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfInitialAssignments * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfInitialAssignments_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfInitialAssignments_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListOfInitialAssignments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfInitialAssignments *arg1 = (ListOfInitialAssignments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfInitialAssignments, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfInitialAssignments" "', argument " "1"" of type '" "ListOfInitialAssignments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfInitialAssignments * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfInitialAssignments_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfInitialAssignments, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfInitialAssignments_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_Rule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rule" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Rule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Rule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Rule,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rule" "', argument " "1"" of type '" "Rule const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rule" "', argument " "1"" of type '" "Rule const &""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (Rule *)new Rule((Rule const &)*arg1);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Rule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_clone" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (Rule *)((Rule const *)arg1)->clone();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_getFormula(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_getFormula" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (std::string *) &((Rule const *)arg1)->getFormula();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_getMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_getMath" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (ASTNode *)((Rule const *)arg1)->getMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_getVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_getVariable" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (std::string *) &((Rule const *)arg1)->getVariable();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_getUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_getUnits" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (std::string *) &((Rule const *)arg1)->getUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_isSetFormula(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_isSetFormula" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->isSetFormula();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_isSetMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_isSetMath" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->isSetMath();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_isSetVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_isSetVariable" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->isSetVariable();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_isSetUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_isSetUnits" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->isSetUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_setFormula(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Rule_setFormula", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_setFormula" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rule_setFormula" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rule_setFormula" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setFormula((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_setMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Rule_setMath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_setMath" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rule_setMath" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (int)(arg1)->setMath((ASTNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_setVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Rule_setVariable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_setVariable" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rule_setVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rule_setVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setVariable((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_setUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Rule_setUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_setUnits" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rule_setUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rule_setUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_unsetVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_unsetVariable" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (int)(arg1)->unsetVariable();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_unsetUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_unsetUnits" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (int)(arg1)->unsetUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_getDerivedUnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_getDerivedUnitDefinition" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_getDerivedUnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_getDerivedUnitDefinition" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (UnitDefinition *)((Rule const *)arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_getDerivedUnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Rule_getDerivedUnitDefinition", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Rule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Rule_getDerivedUnitDefinition__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Rule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Rule_getDerivedUnitDefinition__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Rule_getDerivedUnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Rule::getDerivedUnitDefinition()\n"
    "    Rule::getDerivedUnitDefinition() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Rule_containsUndeclaredUnits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_containsUndeclaredUnits" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)(arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_containsUndeclaredUnits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_containsUndeclaredUnits" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_containsUndeclaredUnits(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Rule_containsUndeclaredUnits", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Rule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Rule_containsUndeclaredUnits__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Rule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Rule_containsUndeclaredUnits__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Rule_containsUndeclaredUnits'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Rule::containsUndeclaredUnits()\n"
    "    Rule::containsUndeclaredUnits() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Rule_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  RuleType_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_getType" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (RuleType_t)((Rule const *)arg1)->getType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_isAlgebraic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_isAlgebraic" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->isAlgebraic();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_isAssignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_isAssignment" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->isAssignment();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_isCompartmentVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_isCompartmentVolume" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->isCompartmentVolume();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_isParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_isParameter" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->isParameter();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_isRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_isRate" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->isRate();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_isScalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_isScalar" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->isScalar();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_isSpeciesConcentration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_isSpeciesConcentration" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->isSpeciesConcentration();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_getTypeCode" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (int)((Rule const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_getL1TypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_getL1TypeCode" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (int)((Rule const *)arg1)->getL1TypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_getElementName" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (std::string *) &((Rule const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_setL1TypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Rule_setL1TypeCode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_setL1TypeCode" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rule_setL1TypeCode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->setL1TypeCode(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_hasRequiredElements" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_hasRequiredAttributes" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (bool)((Rule const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Rule_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_renameSIdRefs" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rule_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rule_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rule_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rule_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Rule_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_renameUnitSIdRefs" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rule_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rule_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rule_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rule_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_getId" "', argument " "1"" of type '" "Rule const *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  result = (std::string *) &((Rule const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_replaceSIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Rule_replaceSIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_replaceSIDWithFunction" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rule_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rule_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rule_replaceSIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceSIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_divideAssignmentsToSIdByFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Rule_divideAssignmentsToSIdByFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_divideAssignmentsToSIdByFunction" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rule_divideAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rule_divideAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rule_divideAssignmentsToSIdByFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->divideAssignmentsToSIdByFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rule_multiplyAssignmentsToSIdByFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Rule *arg1 = (Rule *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Rule_multiplyAssignmentsToSIdByFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rule_multiplyAssignmentsToSIdByFunction" "', argument " "1"" of type '" "Rule *""'"); 
  }
  arg1 = reinterpret_cast< Rule * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rule_multiplyAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rule_multiplyAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rule_multiplyAssignmentsToSIdByFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->multiplyAssignmentsToSIdByFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *Rule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Rule, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Rule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfRules *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfRules" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfRules" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfRules *)new ListOfRules(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfRules *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfRules" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfRules *)new ListOfRules(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfRules(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfRules", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfRules__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfRules__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfRules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfRules::ListOfRules(unsigned int,unsigned int)\n"
    "    ListOfRules::ListOfRules(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfRules_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfRules *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfRules_clone" "', argument " "1"" of type '" "ListOfRules const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfRules * >(argp1);
  result = (ListOfRules *)((ListOfRules const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfRules, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfRules_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfRules_getItemTypeCode" "', argument " "1"" of type '" "ListOfRules const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfRules * >(argp1);
  result = (int)((ListOfRules const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfRules_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfRules_getElementName" "', argument " "1"" of type '" "ListOfRules const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfRules * >(argp1);
  result = (std::string *) &((ListOfRules const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfRules_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfRules_get" "', argument " "1"" of type '" "ListOfRules *""'"); 
  }
  arg1 = reinterpret_cast< ListOfRules * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfRules_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Rule *)(arg1)->get(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfRules_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfRules_get" "', argument " "1"" of type '" "ListOfRules const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfRules * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfRules_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Rule *)((ListOfRules const *)arg1)->get(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfRules_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfRules_get" "', argument " "1"" of type '" "ListOfRules *""'"); 
  }
  arg1 = reinterpret_cast< ListOfRules * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfRules_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfRules_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Rule *)(arg1)->get((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfRules_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfRules_get" "', argument " "1"" of type '" "ListOfRules const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfRules * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfRules_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfRules_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Rule *)((ListOfRules const *)arg1)->get((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfRules_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfRules_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfRules, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfRules_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfRules, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfRules_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfRules, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfRules_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfRules, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfRules_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfRules_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfRules::get(unsigned int)\n"
    "    ListOfRules::get(unsigned int) const\n"
    "    ListOfRules::get(std::string const &)\n"
    "    ListOfRules::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfRules_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfRules_remove" "', argument " "1"" of type '" "ListOfRules *""'"); 
  }
  arg1 = reinterpret_cast< ListOfRules * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfRules_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Rule *)(arg1)->remove(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfRules_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOfRules_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfRules_getElementBySId" "', argument " "1"" of type '" "ListOfRules *""'"); 
  }
  arg1 = reinterpret_cast< ListOfRules * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfRules_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfRules_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfRules_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Rule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfRules, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfRules_remove" "', argument " "1"" of type '" "ListOfRules *""'"); 
  }
  arg1 = reinterpret_cast< ListOfRules * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfRules_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfRules_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Rule *)(arg1)->remove((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfRules_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfRules_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfRules, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfRules_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfRules, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfRules_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfRules_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfRules::remove(unsigned int)\n"
    "    ListOfRules::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListOfRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfRules *arg1 = (ListOfRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfRules, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfRules" "', argument " "1"" of type '" "ListOfRules *""'"); 
  }
  arg1 = reinterpret_cast< ListOfRules * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfRules_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfRules, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfRules_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AlgebraicRule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  AlgebraicRule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AlgebraicRule" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AlgebraicRule" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (AlgebraicRule *)new AlgebraicRule(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AlgebraicRule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AlgebraicRule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  AlgebraicRule *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlgebraicRule" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (AlgebraicRule *)new AlgebraicRule(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AlgebraicRule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AlgebraicRule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AlgebraicRule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AlgebraicRule__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AlgebraicRule__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AlgebraicRule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AlgebraicRule::AlgebraicRule(unsigned int,unsigned int)\n"
    "    AlgebraicRule::AlgebraicRule(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AlgebraicRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  AlgebraicRule *arg1 = (AlgebraicRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AlgebraicRule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlgebraicRule" "', argument " "1"" of type '" "AlgebraicRule *""'"); 
  }
  arg1 = reinterpret_cast< AlgebraicRule * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlgebraicRule_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  AlgebraicRule *arg1 = (AlgebraicRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AlgebraicRule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AlgebraicRule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgebraicRule_clone" "', argument " "1"" of type '" "AlgebraicRule const *""'"); 
  }
  arg1 = reinterpret_cast< AlgebraicRule * >(argp1);
  result = (AlgebraicRule *)((AlgebraicRule const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AlgebraicRule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlgebraicRule_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  AlgebraicRule *arg1 = (AlgebraicRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AlgebraicRule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlgebraicRule_hasRequiredAttributes" "', argument " "1"" of type '" "AlgebraicRule const *""'"); 
  }
  arg1 = reinterpret_cast< AlgebraicRule * >(argp1);
  result = (bool)((AlgebraicRule const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AlgebraicRule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_AlgebraicRule, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AlgebraicRule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AssignmentRule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  AssignmentRule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AssignmentRule" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AssignmentRule" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (AssignmentRule *)new AssignmentRule(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AssignmentRule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssignmentRule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  AssignmentRule *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AssignmentRule" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (AssignmentRule *)new AssignmentRule(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AssignmentRule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssignmentRule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AssignmentRule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AssignmentRule__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AssignmentRule__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AssignmentRule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AssignmentRule::AssignmentRule(unsigned int,unsigned int)\n"
    "    AssignmentRule::AssignmentRule(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AssignmentRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  AssignmentRule *arg1 = (AssignmentRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AssignmentRule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AssignmentRule" "', argument " "1"" of type '" "AssignmentRule *""'"); 
  }
  arg1 = reinterpret_cast< AssignmentRule * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AssignmentRule_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  AssignmentRule *arg1 = (AssignmentRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AssignmentRule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AssignmentRule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AssignmentRule_clone" "', argument " "1"" of type '" "AssignmentRule const *""'"); 
  }
  arg1 = reinterpret_cast< AssignmentRule * >(argp1);
  result = (AssignmentRule *)((AssignmentRule const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AssignmentRule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AssignmentRule_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  AssignmentRule *arg1 = (AssignmentRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AssignmentRule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AssignmentRule_hasRequiredAttributes" "', argument " "1"" of type '" "AssignmentRule const *""'"); 
  }
  arg1 = reinterpret_cast< AssignmentRule * >(argp1);
  result = (bool)((AssignmentRule const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AssignmentRule_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  AssignmentRule *arg1 = (AssignmentRule *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "AssignmentRule_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AssignmentRule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AssignmentRule_renameSIdRefs" "', argument " "1"" of type '" "AssignmentRule *""'"); 
  }
  arg1 = reinterpret_cast< AssignmentRule * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AssignmentRule_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AssignmentRule_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AssignmentRule_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AssignmentRule_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *AssignmentRule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_AssignmentRule, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AssignmentRule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RateRule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  RateRule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RateRule" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RateRule" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (RateRule *)new RateRule(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RateRule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateRule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  RateRule *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RateRule" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (RateRule *)new RateRule(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RateRule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateRule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RateRule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RateRule__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_RateRule__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RateRule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RateRule::RateRule(unsigned int,unsigned int)\n"
    "    RateRule::RateRule(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RateRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  RateRule *arg1 = (RateRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RateRule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RateRule" "', argument " "1"" of type '" "RateRule *""'"); 
  }
  arg1 = reinterpret_cast< RateRule * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateRule_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  RateRule *arg1 = (RateRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  RateRule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RateRule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateRule_clone" "', argument " "1"" of type '" "RateRule const *""'"); 
  }
  arg1 = reinterpret_cast< RateRule * >(argp1);
  result = (RateRule *)((RateRule const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RateRule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateRule_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  RateRule *arg1 = (RateRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RateRule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateRule_hasRequiredAttributes" "', argument " "1"" of type '" "RateRule const *""'"); 
  }
  arg1 = reinterpret_cast< RateRule * >(argp1);
  result = (bool)((RateRule const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateRule_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  RateRule *arg1 = (RateRule *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RateRule_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RateRule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateRule_renameSIdRefs" "', argument " "1"" of type '" "RateRule *""'"); 
  }
  arg1 = reinterpret_cast< RateRule * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RateRule_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RateRule_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RateRule_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RateRule_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *RateRule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RateRule, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RateRule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Constraint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Constraint *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Constraint" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Constraint" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Constraint *)new Constraint(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Constraint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Constraint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Constraint *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Constraint" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (Constraint *)new Constraint(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Constraint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Constraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Constraint" "', argument " "1"" of type '" "Constraint *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Constraint__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Constraint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Constraint *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Constraint,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Constraint" "', argument " "1"" of type '" "Constraint const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Constraint" "', argument " "1"" of type '" "Constraint const &""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  {
    try {
      result = (Constraint *)new Constraint((Constraint const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Constraint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Constraint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Constraint", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Constraint__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Constraint, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Constraint__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Constraint__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Constraint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Constraint::Constraint(unsigned int,unsigned int)\n"
    "    Constraint::Constraint(SBMLNamespaces *)\n"
    "    Constraint::Constraint(Constraint const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Constraint_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Constraint *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_clone" "', argument " "1"" of type '" "Constraint const *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  result = (Constraint *)((Constraint const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Constraint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_getMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_getMessage" "', argument " "1"" of type '" "Constraint const *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  result = (XMLNode *)((Constraint const *)arg1)->getMessage();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_getMessageString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_getMessageString" "', argument " "1"" of type '" "Constraint const *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  result = ((Constraint const *)arg1)->getMessageString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_getMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_getMath" "', argument " "1"" of type '" "Constraint const *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  result = (ASTNode *)((Constraint const *)arg1)->getMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_isSetMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_isSetMessage" "', argument " "1"" of type '" "Constraint const *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  result = (bool)((Constraint const *)arg1)->isSetMessage();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_isSetMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_isSetMath" "', argument " "1"" of type '" "Constraint const *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  result = (bool)((Constraint const *)arg1)->isSetMath();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_setMessage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_setMessage" "', argument " "1"" of type '" "Constraint *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Constraint_setMessage" "', argument " "2"" of type '" "XMLNode const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  result = (int)(arg1)->setMessage((XMLNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_setMessage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_setMessage" "', argument " "1"" of type '" "Constraint *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Constraint_setMessage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Constraint_setMessage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Constraint_setMessage" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (int)(arg1)->setMessage((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_setMessage__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_setMessage" "', argument " "1"" of type '" "Constraint *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Constraint_setMessage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Constraint_setMessage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setMessage((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_setMessage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Constraint_setMessage", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Constraint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Constraint_setMessage__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Constraint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Constraint_setMessage__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Constraint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Constraint_setMessage__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Constraint_setMessage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Constraint::setMessage(XMLNode const *)\n"
    "    Constraint::setMessage(std::string const &,bool)\n"
    "    Constraint::setMessage(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Constraint_setMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Constraint_setMath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_setMath" "', argument " "1"" of type '" "Constraint *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Constraint_setMath" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (int)(arg1)->setMath((ASTNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_unsetMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_unsetMessage" "', argument " "1"" of type '" "Constraint *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  result = (int)(arg1)->unsetMessage();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Constraint_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_renameSIdRefs" "', argument " "1"" of type '" "Constraint *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Constraint_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Constraint_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Constraint_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Constraint_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Constraint_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_renameUnitSIdRefs" "', argument " "1"" of type '" "Constraint *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Constraint_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Constraint_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Constraint_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Constraint_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_replaceSIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Constraint_replaceSIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_replaceSIDWithFunction" "', argument " "1"" of type '" "Constraint *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Constraint_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Constraint_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Constraint_replaceSIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceSIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_getTypeCode" "', argument " "1"" of type '" "Constraint const *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  result = (int)((Constraint const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_getElementName" "', argument " "1"" of type '" "Constraint const *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  result = (std::string *) &((Constraint const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Constraint_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Constraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Constraint_hasRequiredElements" "', argument " "1"" of type '" "Constraint const *""'"); 
  }
  arg1 = reinterpret_cast< Constraint * >(argp1);
  result = (bool)((Constraint const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Constraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Constraint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Constraint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfConstraints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfConstraints *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfConstraints" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfConstraints" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfConstraints *)new ListOfConstraints(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfConstraints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfConstraints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfConstraints *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfConstraints" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfConstraints *)new ListOfConstraints(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfConstraints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfConstraints(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfConstraints", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfConstraints__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfConstraints__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfConstraints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfConstraints::ListOfConstraints(unsigned int,unsigned int)\n"
    "    ListOfConstraints::ListOfConstraints(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfConstraints_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfConstraints *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfConstraints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfConstraints_clone" "', argument " "1"" of type '" "ListOfConstraints const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfConstraints * >(argp1);
  result = (ListOfConstraints *)((ListOfConstraints const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfConstraints, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfConstraints_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfConstraints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfConstraints_getItemTypeCode" "', argument " "1"" of type '" "ListOfConstraints const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfConstraints * >(argp1);
  result = (int)((ListOfConstraints const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfConstraints_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfConstraints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfConstraints_getElementName" "', argument " "1"" of type '" "ListOfConstraints const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfConstraints * >(argp1);
  result = (std::string *) &((ListOfConstraints const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfConstraints_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Constraint *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfConstraints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfConstraints_get" "', argument " "1"" of type '" "ListOfConstraints *""'"); 
  }
  arg1 = reinterpret_cast< ListOfConstraints * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfConstraints_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Constraint *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Constraint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfConstraints_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Constraint *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfConstraints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfConstraints_get" "', argument " "1"" of type '" "ListOfConstraints const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfConstraints * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfConstraints_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Constraint *)((ListOfConstraints const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Constraint, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfConstraints_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfConstraints_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfConstraints, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfConstraints_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfConstraints, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfConstraints_get__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfConstraints_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfConstraints::get(unsigned int)\n"
    "    ListOfConstraints::get(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfConstraints_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Constraint *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOfConstraints_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfConstraints, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfConstraints_remove" "', argument " "1"" of type '" "ListOfConstraints *""'"); 
  }
  arg1 = reinterpret_cast< ListOfConstraints * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfConstraints_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Constraint *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Constraint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListOfConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfConstraints *arg1 = (ListOfConstraints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfConstraints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfConstraints" "', argument " "1"" of type '" "ListOfConstraints *""'"); 
  }
  arg1 = reinterpret_cast< ListOfConstraints * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfConstraints, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Reaction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Reaction" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Reaction" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Reaction *)new Reaction(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Reaction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Reaction *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Reaction" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (Reaction *)new Reaction(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Reaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Reaction" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Reaction__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Reaction *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Reaction,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Reaction" "', argument " "1"" of type '" "Reaction const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Reaction" "', argument " "1"" of type '" "Reaction const &""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    try {
      result = (Reaction *)new Reaction((Reaction const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Reaction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Reaction", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Reaction__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Reaction, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Reaction__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Reaction__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Reaction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::Reaction(unsigned int,unsigned int)\n"
    "    Reaction::Reaction(SBMLNamespaces *)\n"
    "    Reaction::Reaction(Reaction const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Reaction *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_clone" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (Reaction *)((Reaction const *)arg1)->clone();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Reaction_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getElementBySId" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getElementByMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Reaction_getElementByMetaId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getElementByMetaId" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementByMetaId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Reaction_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_renameSIdRefs" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Reaction_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_initDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_initDefaults" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  (arg1)->initDefaults();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getId" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (std::string *) &((Reaction const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getName" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (std::string *) &((Reaction const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getKineticLaw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  KineticLaw *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getKineticLaw" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (KineticLaw *)((Reaction const *)arg1)->getKineticLaw();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KineticLaw, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getKineticLaw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  KineticLaw *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getKineticLaw" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (KineticLaw *)(arg1)->getKineticLaw();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KineticLaw, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getKineticLaw(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_getKineticLaw", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Reaction_getKineticLaw__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Reaction_getKineticLaw__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_getKineticLaw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::getKineticLaw() const\n"
    "    Reaction::getKineticLaw()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_getReversible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getReversible" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (bool)((Reaction const *)arg1)->getReversible();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getFast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getFast" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (bool)((Reaction const *)arg1)->getFast();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getCompartment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getCompartment" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (std::string *) &((Reaction const *)arg1)->getCompartment();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_isSetId" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (bool)((Reaction const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_isSetName" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (bool)((Reaction const *)arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_isSetKineticLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_isSetKineticLaw" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (bool)((Reaction const *)arg1)->isSetKineticLaw();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_isSetFast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_isSetFast" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (bool)((Reaction const *)arg1)->isSetFast();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_isSetCompartment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_isSetCompartment" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (bool)((Reaction const *)arg1)->isSetCompartment();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_isSetReversible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_isSetReversible" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (bool)((Reaction const *)arg1)->isSetReversible();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Reaction_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_setId" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Reaction_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_setName" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_setKineticLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  KineticLaw *arg2 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Reaction_setKineticLaw", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_setKineticLaw" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_setKineticLaw" "', argument " "2"" of type '" "KineticLaw const *""'"); 
  }
  arg2 = reinterpret_cast< KineticLaw * >(argp2);
  result = (int)(arg1)->setKineticLaw((KineticLaw const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_setReversible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Reaction_setReversible", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_setReversible" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reaction_setReversible" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setReversible(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_setFast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Reaction_setFast", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_setFast" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reaction_setFast" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setFast(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_setCompartment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Reaction_setCompartment", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_setCompartment" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_setCompartment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_setCompartment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setCompartment((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_unsetName" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_unsetKineticLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_unsetKineticLaw" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (int)(arg1)->unsetKineticLaw();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_unsetFast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_unsetFast" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (int)(arg1)->unsetFast();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_unsetCompartment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_unsetCompartment" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (int)(arg1)->unsetCompartment();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_unsetReversible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_unsetReversible" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (int)(arg1)->unsetReversible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addReactant__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  SpeciesReference *arg2 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addReactant" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addReactant" "', argument " "2"" of type '" "SpeciesReference const *""'"); 
  }
  arg2 = reinterpret_cast< SpeciesReference * >(argp2);
  result = (int)(arg1)->addReactant((SpeciesReference const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addReactant__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  Species *arg2 = (Species *) 0 ;
  double arg3 ;
  std::string arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addReactant" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addReactant" "', argument " "2"" of type '" "Species const *""'"); 
  }
  arg2 = reinterpret_cast< Species * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Reaction_addReactant" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Reaction_addReactant" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Reaction_addReactant" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (int)(arg1)->addReactant((Species const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addReactant__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  Species *arg2 = (Species *) 0 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addReactant" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addReactant" "', argument " "2"" of type '" "Species const *""'"); 
  }
  arg2 = reinterpret_cast< Species * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Reaction_addReactant" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Reaction_addReactant" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->addReactant((Species const *)arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addReactant__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  Species *arg2 = (Species *) 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addReactant" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addReactant" "', argument " "2"" of type '" "Species const *""'"); 
  }
  arg2 = reinterpret_cast< Species * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Reaction_addReactant" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (int)(arg1)->addReactant((Species const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addReactant__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  Species *arg2 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addReactant" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addReactant" "', argument " "2"" of type '" "Species const *""'"); 
  }
  arg2 = reinterpret_cast< Species * >(argp2);
  result = (int)(arg1)->addReactant((Species const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addReactant(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_addReactant", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SpeciesReference, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_addReactant__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Species, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_addReactant__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Species, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Reaction_addReactant__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Species, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Reaction_addReactant__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Species, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Reaction_addReactant__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_addReactant'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::addReactant(SpeciesReference const *)\n"
    "    Reaction::addReactant(Species const *,double,std::string const,bool)\n"
    "    Reaction::addReactant(Species const *,double,std::string const)\n"
    "    Reaction::addReactant(Species const *,double)\n"
    "    Reaction::addReactant(Species const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_addProduct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  SpeciesReference *arg2 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addProduct" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addProduct" "', argument " "2"" of type '" "SpeciesReference const *""'"); 
  }
  arg2 = reinterpret_cast< SpeciesReference * >(argp2);
  result = (int)(arg1)->addProduct((SpeciesReference const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addProduct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  Species *arg2 = (Species *) 0 ;
  double arg3 ;
  std::string arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addProduct" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addProduct" "', argument " "2"" of type '" "Species const *""'"); 
  }
  arg2 = reinterpret_cast< Species * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Reaction_addProduct" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Reaction_addProduct" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Reaction_addProduct" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (int)(arg1)->addProduct((Species const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addProduct__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  Species *arg2 = (Species *) 0 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addProduct" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addProduct" "', argument " "2"" of type '" "Species const *""'"); 
  }
  arg2 = reinterpret_cast< Species * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Reaction_addProduct" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Reaction_addProduct" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->addProduct((Species const *)arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addProduct__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  Species *arg2 = (Species *) 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addProduct" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addProduct" "', argument " "2"" of type '" "Species const *""'"); 
  }
  arg2 = reinterpret_cast< Species * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Reaction_addProduct" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (int)(arg1)->addProduct((Species const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addProduct__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  Species *arg2 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addProduct" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addProduct" "', argument " "2"" of type '" "Species const *""'"); 
  }
  arg2 = reinterpret_cast< Species * >(argp2);
  result = (int)(arg1)->addProduct((Species const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addProduct(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_addProduct", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SpeciesReference, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_addProduct__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Species, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_addProduct__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Species, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Reaction_addProduct__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Species, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Reaction_addProduct__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Species, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Reaction_addProduct__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_addProduct'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::addProduct(SpeciesReference const *)\n"
    "    Reaction::addProduct(Species const *,double,std::string const,bool)\n"
    "    Reaction::addProduct(Species const *,double,std::string const)\n"
    "    Reaction::addProduct(Species const *,double)\n"
    "    Reaction::addProduct(Species const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_addModifier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  ModifierSpeciesReference *arg2 = (ModifierSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addModifier" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addModifier" "', argument " "2"" of type '" "ModifierSpeciesReference const *""'"); 
  }
  arg2 = reinterpret_cast< ModifierSpeciesReference * >(argp2);
  result = (int)(arg1)->addModifier((ModifierSpeciesReference const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addModifier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  Species *arg2 = (Species *) 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addModifier" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addModifier" "', argument " "2"" of type '" "Species const *""'"); 
  }
  arg2 = reinterpret_cast< Species * >(argp2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Reaction_addModifier" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->addModifier((Species const *)arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addModifier__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  Species *arg2 = (Species *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_addModifier" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Species, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_addModifier" "', argument " "2"" of type '" "Species const *""'"); 
  }
  arg2 = reinterpret_cast< Species * >(argp2);
  result = (int)(arg1)->addModifier((Species const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_addModifier(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_addModifier", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ModifierSpeciesReference, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_addModifier__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Species, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_addModifier__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Species, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Reaction_addModifier__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_addModifier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::addModifier(ModifierSpeciesReference const *)\n"
    "    Reaction::addModifier(Species const *,std::string const)\n"
    "    Reaction::addModifier(Species const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_createReactant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SpeciesReference *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_createReactant" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (SpeciesReference *)(arg1)->createReactant();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_createProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SpeciesReference *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_createProduct" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (SpeciesReference *)(arg1)->createProduct();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_createModifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ModifierSpeciesReference *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_createModifier" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (ModifierSpeciesReference *)(arg1)->createModifier();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_createKineticLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  KineticLaw *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_createKineticLaw" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (KineticLaw *)(arg1)->createKineticLaw();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KineticLaw, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getListOfReactants__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpeciesReferences *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getListOfReactants" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (ListOfSpeciesReferences *)((Reaction const *)arg1)->getListOfReactants();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getListOfReactants__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpeciesReferences *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getListOfReactants" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (ListOfSpeciesReferences *)(arg1)->getListOfReactants();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getListOfReactants(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_getListOfReactants", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Reaction_getListOfReactants__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Reaction_getListOfReactants__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_getListOfReactants'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::getListOfReactants() const\n"
    "    Reaction::getListOfReactants()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_getListOfProducts__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpeciesReferences *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getListOfProducts" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (ListOfSpeciesReferences *)((Reaction const *)arg1)->getListOfProducts();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getListOfProducts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpeciesReferences *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getListOfProducts" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (ListOfSpeciesReferences *)(arg1)->getListOfProducts();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getListOfProducts(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_getListOfProducts", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Reaction_getListOfProducts__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Reaction_getListOfProducts__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_getListOfProducts'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::getListOfProducts() const\n"
    "    Reaction::getListOfProducts()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_getListOfModifiers__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpeciesReferences *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getListOfModifiers" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (ListOfSpeciesReferences *)((Reaction const *)arg1)->getListOfModifiers();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getListOfModifiers__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpeciesReferences *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getListOfModifiers" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (ListOfSpeciesReferences *)(arg1)->getListOfModifiers();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getListOfModifiers(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_getListOfModifiers", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Reaction_getListOfModifiers__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Reaction_getListOfModifiers__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_getListOfModifiers'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::getListOfModifiers() const\n"
    "    Reaction::getListOfModifiers()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_getReactant__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getReactant" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reaction_getReactant" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SpeciesReference *)((Reaction const *)arg1)->getReactant(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getReactant__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getReactant" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reaction_getReactant" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SpeciesReference *)(arg1)->getReactant(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getReactant__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getReactant" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_getReactant" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_getReactant" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesReference *)((Reaction const *)arg1)->getReactant((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getReactant__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getReactant" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_getReactant" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_getReactant" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesReference *)(arg1)->getReactant((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getReactant(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_getReactant", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Reaction_getReactant__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Reaction_getReactant__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_getReactant__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_getReactant__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_getReactant'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::getReactant(unsigned int) const\n"
    "    Reaction::getReactant(unsigned int)\n"
    "    Reaction::getReactant(std::string const &) const\n"
    "    Reaction::getReactant(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_getProduct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getProduct" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reaction_getProduct" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SpeciesReference *)((Reaction const *)arg1)->getProduct(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getProduct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getProduct" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reaction_getProduct" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SpeciesReference *)(arg1)->getProduct(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getProduct__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getProduct" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_getProduct" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_getProduct" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesReference *)((Reaction const *)arg1)->getProduct((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getProduct__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getProduct" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_getProduct" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_getProduct" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesReference *)(arg1)->getProduct((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getProduct(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_getProduct", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Reaction_getProduct__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Reaction_getProduct__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_getProduct__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_getProduct__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_getProduct'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::getProduct(unsigned int) const\n"
    "    Reaction::getProduct(unsigned int)\n"
    "    Reaction::getProduct(std::string const &) const\n"
    "    Reaction::getProduct(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_getModifier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ModifierSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getModifier" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reaction_getModifier" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ModifierSpeciesReference *)((Reaction const *)arg1)->getModifier(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getModifier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ModifierSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getModifier" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reaction_getModifier" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ModifierSpeciesReference *)(arg1)->getModifier(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getModifier__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  ModifierSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getModifier" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_getModifier" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_getModifier" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ModifierSpeciesReference *)((Reaction const *)arg1)->getModifier((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getModifier__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  ModifierSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getModifier" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_getModifier" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_getModifier" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ModifierSpeciesReference *)(arg1)->getModifier((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getModifier(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_getModifier", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Reaction_getModifier__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Reaction_getModifier__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_getModifier__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_getModifier__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_getModifier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::getModifier(unsigned int) const\n"
    "    Reaction::getModifier(unsigned int)\n"
    "    Reaction::getModifier(std::string const &) const\n"
    "    Reaction::getModifier(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_getNumReactants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getNumReactants" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (unsigned int)((Reaction const *)arg1)->getNumReactants();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getNumProducts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getNumProducts" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (unsigned int)((Reaction const *)arg1)->getNumProducts();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getNumModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getNumModifiers" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (unsigned int)((Reaction const *)arg1)->getNumModifiers();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_removeReactant__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_removeReactant" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reaction_removeReactant" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SpeciesReference *)(arg1)->removeReactant(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_removeReactant__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_removeReactant" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_removeReactant" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_removeReactant" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesReference *)(arg1)->removeReactant((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_removeReactant(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_removeReactant", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Reaction_removeReactant__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_removeReactant__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_removeReactant'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::removeReactant(unsigned int)\n"
    "    Reaction::removeReactant(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_removeProduct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_removeProduct" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reaction_removeProduct" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SpeciesReference *)(arg1)->removeProduct(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_removeProduct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_removeProduct" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_removeProduct" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_removeProduct" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SpeciesReference *)(arg1)->removeProduct((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_removeProduct(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_removeProduct", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Reaction_removeProduct__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_removeProduct__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_removeProduct'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::removeProduct(unsigned int)\n"
    "    Reaction::removeProduct(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_removeModifier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ModifierSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_removeModifier" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reaction_removeModifier" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ModifierSpeciesReference *)(arg1)->removeModifier(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_removeModifier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  ModifierSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_removeModifier" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_removeModifier" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_removeModifier" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ModifierSpeciesReference *)(arg1)->removeModifier((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_removeModifier(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Reaction_removeModifier", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Reaction_removeModifier__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reaction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reaction_removeModifier__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Reaction_removeModifier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Reaction::removeModifier(unsigned int)\n"
    "    Reaction::removeModifier(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reaction_connectToChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_connectToChild" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  (arg1)->connectToChild();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_enablePackageInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Reaction_enablePackageInternal", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_enablePackageInternal" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Reaction_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Reaction_enablePackageInternal" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->enablePackageInternal((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_updateSBMLNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Reaction_updateSBMLNamespace", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_updateSBMLNamespace" "', argument " "1"" of type '" "Reaction *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reaction_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reaction_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Reaction_updateSBMLNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Reaction_updateSBMLNamespace" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  (arg1)->updateSBMLNamespace((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getTypeCode" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (int)((Reaction const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_getElementName" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (std::string *) &((Reaction const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reaction_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Reaction *arg1 = (Reaction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Reaction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reaction_hasRequiredAttributes" "', argument " "1"" of type '" "Reaction const *""'"); 
  }
  arg1 = reinterpret_cast< Reaction * >(argp1);
  result = (bool)((Reaction const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Reaction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Reaction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Reaction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfReactions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfReactions *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfReactions" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfReactions" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfReactions *)new ListOfReactions(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfReactions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfReactions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfReactions *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfReactions" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfReactions *)new ListOfReactions(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfReactions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfReactions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfReactions", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfReactions__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfReactions__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfReactions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfReactions::ListOfReactions(unsigned int,unsigned int)\n"
    "    ListOfReactions::ListOfReactions(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfReactions_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfReactions *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfReactions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfReactions_clone" "', argument " "1"" of type '" "ListOfReactions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfReactions * >(argp1);
  result = (ListOfReactions *)((ListOfReactions const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfReactions, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfReactions_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfReactions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfReactions_getItemTypeCode" "', argument " "1"" of type '" "ListOfReactions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfReactions * >(argp1);
  result = (int)((ListOfReactions const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfReactions_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfReactions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfReactions_getElementName" "', argument " "1"" of type '" "ListOfReactions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfReactions * >(argp1);
  result = (std::string *) &((ListOfReactions const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfReactions_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfReactions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfReactions_get" "', argument " "1"" of type '" "ListOfReactions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfReactions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfReactions_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Reaction *)(arg1)->get(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfReactions_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfReactions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfReactions_get" "', argument " "1"" of type '" "ListOfReactions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfReactions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfReactions_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Reaction *)((ListOfReactions const *)arg1)->get(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfReactions_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfReactions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfReactions_get" "', argument " "1"" of type '" "ListOfReactions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfReactions * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfReactions_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfReactions_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Reaction *)(arg1)->get((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfReactions_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfReactions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfReactions_get" "', argument " "1"" of type '" "ListOfReactions const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfReactions * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfReactions_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfReactions_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Reaction *)((ListOfReactions const *)arg1)->get((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfReactions_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfReactions_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfReactions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfReactions_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfReactions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfReactions_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfReactions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfReactions_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfReactions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfReactions_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfReactions_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfReactions::get(unsigned int)\n"
    "    ListOfReactions::get(unsigned int) const\n"
    "    ListOfReactions::get(std::string const &)\n"
    "    ListOfReactions::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfReactions_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfReactions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfReactions_remove" "', argument " "1"" of type '" "ListOfReactions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfReactions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfReactions_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Reaction *)(arg1)->remove(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfReactions_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Reaction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfReactions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfReactions_remove" "', argument " "1"" of type '" "ListOfReactions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfReactions * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfReactions_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfReactions_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Reaction *)(arg1)->remove((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfReactions_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfReactions_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfReactions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfReactions_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfReactions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfReactions_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfReactions_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfReactions::remove(unsigned int)\n"
    "    ListOfReactions::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListOfReactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfReactions *arg1 = (ListOfReactions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfReactions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfReactions" "', argument " "1"" of type '" "ListOfReactions *""'"); 
  }
  arg1 = reinterpret_cast< ListOfReactions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfReactions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfReactions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfReactions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KineticLaw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  KineticLaw *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KineticLaw" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KineticLaw" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (KineticLaw *)new KineticLaw(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KineticLaw, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KineticLaw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  KineticLaw *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KineticLaw" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (KineticLaw *)new KineticLaw(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KineticLaw, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KineticLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KineticLaw" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KineticLaw__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  KineticLaw *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_KineticLaw,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KineticLaw" "', argument " "1"" of type '" "KineticLaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KineticLaw" "', argument " "1"" of type '" "KineticLaw const &""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    try {
      result = (KineticLaw *)new KineticLaw((KineticLaw const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KineticLaw, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KineticLaw(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_KineticLaw", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_KineticLaw__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_KineticLaw, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_KineticLaw__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_KineticLaw__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_KineticLaw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    KineticLaw::KineticLaw(unsigned int,unsigned int)\n"
    "    KineticLaw::KineticLaw(SBMLNamespaces *)\n"
    "    KineticLaw::KineticLaw(KineticLaw const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KineticLaw_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  KineticLaw *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_clone" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (KineticLaw *)((KineticLaw const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KineticLaw, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getElementBySId" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getElementByMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_getElementByMetaId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getElementByMetaId" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementByMetaId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getFormula(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getFormula" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (std::string *) &((KineticLaw const *)arg1)->getFormula();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getMath" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (ASTNode *)((KineticLaw const *)arg1)->getMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getTimeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getTimeUnits" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (std::string *) &((KineticLaw const *)arg1)->getTimeUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getSubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getSubstanceUnits" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (std::string *) &((KineticLaw const *)arg1)->getSubstanceUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_isSetFormula(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_isSetFormula" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (bool)((KineticLaw const *)arg1)->isSetFormula();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_isSetMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_isSetMath" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (bool)((KineticLaw const *)arg1)->isSetMath();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_isSetTimeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_isSetTimeUnits" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (bool)((KineticLaw const *)arg1)->isSetTimeUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_isSetSubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_isSetSubstanceUnits" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (bool)((KineticLaw const *)arg1)->isSetSubstanceUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_setFormula(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_setFormula", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_setFormula" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_setFormula" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_setFormula" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setFormula((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_setMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_setMath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_setMath" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_setMath" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (int)(arg1)->setMath((ASTNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_setTimeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_setTimeUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_setTimeUnits" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_setTimeUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_setTimeUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setTimeUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_setSubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_setSubstanceUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_setSubstanceUnits" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_setSubstanceUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_setSubstanceUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setSubstanceUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_unsetTimeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_unsetTimeUnits" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (int)(arg1)->unsetTimeUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_unsetSubstanceUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_unsetSubstanceUnits" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (int)(arg1)->unsetSubstanceUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_addParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  Parameter *arg2 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_addParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_addParameter" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_addParameter" "', argument " "2"" of type '" "Parameter const *""'"); 
  }
  arg2 = reinterpret_cast< Parameter * >(argp2);
  result = (int)(arg1)->addParameter((Parameter const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_addLocalParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  LocalParameter *arg2 = (LocalParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_addLocalParameter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_addLocalParameter" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_addLocalParameter" "', argument " "2"" of type '" "LocalParameter const *""'"); 
  }
  arg2 = reinterpret_cast< LocalParameter * >(argp2);
  result = (int)(arg1)->addLocalParameter((LocalParameter const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_createParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Parameter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_createParameter" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (Parameter *)(arg1)->createParameter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_createLocalParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  LocalParameter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_createLocalParameter" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (LocalParameter *)(arg1)->createLocalParameter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getListOfParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfParameters *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getListOfParameters" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (ListOfParameters *)((KineticLaw const *)arg1)->getListOfParameters();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfParameters, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getListOfParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfParameters *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getListOfParameters" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (ListOfParameters *)(arg1)->getListOfParameters();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfParameters, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getListOfParameters(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KineticLaw_getListOfParameters", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KineticLaw_getListOfParameters__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KineticLaw_getListOfParameters__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KineticLaw_getListOfParameters'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    KineticLaw::getListOfParameters() const\n"
    "    KineticLaw::getListOfParameters()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getListOfLocalParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfLocalParameters *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getListOfLocalParameters" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (ListOfLocalParameters *)((KineticLaw const *)arg1)->getListOfLocalParameters();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfLocalParameters, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getListOfLocalParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfLocalParameters *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getListOfLocalParameters" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (ListOfLocalParameters *)(arg1)->getListOfLocalParameters();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfLocalParameters, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getListOfLocalParameters(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KineticLaw_getListOfLocalParameters", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KineticLaw_getListOfLocalParameters__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KineticLaw_getListOfLocalParameters__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KineticLaw_getListOfLocalParameters'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    KineticLaw::getListOfLocalParameters() const\n"
    "    KineticLaw::getListOfLocalParameters()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getParameter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getParameter" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KineticLaw_getParameter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Parameter *)((KineticLaw const *)arg1)->getParameter(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getParameter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getParameter" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KineticLaw_getParameter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Parameter *)(arg1)->getParameter(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getLocalParameter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getLocalParameter" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KineticLaw_getLocalParameter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (LocalParameter *)((KineticLaw const *)arg1)->getLocalParameter(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getLocalParameter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getLocalParameter" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KineticLaw_getLocalParameter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (LocalParameter *)(arg1)->getLocalParameter(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getParameter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getParameter" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_getParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_getParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Parameter *)((KineticLaw const *)arg1)->getParameter((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getParameter__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getParameter" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_getParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_getParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Parameter *)(arg1)->getParameter((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getParameter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KineticLaw_getParameter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KineticLaw_getParameter__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KineticLaw_getParameter__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KineticLaw_getParameter__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KineticLaw_getParameter__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KineticLaw_getParameter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    KineticLaw::getParameter(unsigned int) const\n"
    "    KineticLaw::getParameter(unsigned int)\n"
    "    KineticLaw::getParameter(std::string const &) const\n"
    "    KineticLaw::getParameter(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getLocalParameter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getLocalParameter" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_getLocalParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_getLocalParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (LocalParameter *)((KineticLaw const *)arg1)->getLocalParameter((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getLocalParameter__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getLocalParameter" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_getLocalParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_getLocalParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (LocalParameter *)(arg1)->getLocalParameter((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getLocalParameter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KineticLaw_getLocalParameter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KineticLaw_getLocalParameter__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KineticLaw_getLocalParameter__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KineticLaw_getLocalParameter__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KineticLaw_getLocalParameter__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KineticLaw_getLocalParameter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    KineticLaw::getLocalParameter(unsigned int) const\n"
    "    KineticLaw::getLocalParameter(unsigned int)\n"
    "    KineticLaw::getLocalParameter(std::string const &) const\n"
    "    KineticLaw::getLocalParameter(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getNumParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getNumParameters" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (unsigned int)((KineticLaw const *)arg1)->getNumParameters();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getNumLocalParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getNumLocalParameters" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (unsigned int)((KineticLaw const *)arg1)->getNumLocalParameters();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getDerivedUnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getDerivedUnitDefinition" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getDerivedUnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getDerivedUnitDefinition" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (UnitDefinition *)((KineticLaw const *)arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getDerivedUnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KineticLaw_getDerivedUnitDefinition", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KineticLaw_getDerivedUnitDefinition__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KineticLaw_getDerivedUnitDefinition__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KineticLaw_getDerivedUnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    KineticLaw::getDerivedUnitDefinition()\n"
    "    KineticLaw::getDerivedUnitDefinition() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KineticLaw_containsUndeclaredUnits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_containsUndeclaredUnits" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (bool)(arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_containsUndeclaredUnits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_containsUndeclaredUnits" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (bool)((KineticLaw const *)arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_containsUndeclaredUnits(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KineticLaw_containsUndeclaredUnits", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KineticLaw_containsUndeclaredUnits__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KineticLaw_containsUndeclaredUnits__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KineticLaw_containsUndeclaredUnits'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    KineticLaw::containsUndeclaredUnits()\n"
    "    KineticLaw::containsUndeclaredUnits() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KineticLaw_removeParameter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_removeParameter" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KineticLaw_removeParameter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Parameter *)(arg1)->removeParameter(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_removeLocalParameter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_removeLocalParameter" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KineticLaw_removeLocalParameter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (LocalParameter *)(arg1)->removeLocalParameter(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_removeParameter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Parameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_removeParameter" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_removeParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_removeParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Parameter *)(arg1)->removeParameter((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_removeParameter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KineticLaw_removeParameter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KineticLaw_removeParameter__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KineticLaw_removeParameter__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KineticLaw_removeParameter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    KineticLaw::removeParameter(unsigned int)\n"
    "    KineticLaw::removeParameter(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KineticLaw_removeLocalParameter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  LocalParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_removeLocalParameter" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_removeLocalParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_removeLocalParameter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (LocalParameter *)(arg1)->removeLocalParameter((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LocalParameter, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_removeLocalParameter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KineticLaw_removeLocalParameter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KineticLaw_removeLocalParameter__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_KineticLaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KineticLaw_removeLocalParameter__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KineticLaw_removeLocalParameter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    KineticLaw::removeLocalParameter(unsigned int)\n"
    "    KineticLaw::removeLocalParameter(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KineticLaw_connectToChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_connectToChild" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  (arg1)->connectToChild();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_enablePackageInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_enablePackageInternal", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_enablePackageInternal" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KineticLaw_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "KineticLaw_enablePackageInternal" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->enablePackageInternal((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_updateSBMLNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_updateSBMLNamespace", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_updateSBMLNamespace" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KineticLaw_updateSBMLNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "KineticLaw_updateSBMLNamespace" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  (arg1)->updateSBMLNamespace((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getTypeCode" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (int)((KineticLaw const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_getElementName" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (std::string *) &((KineticLaw const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_hasRequiredAttributes" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (bool)((KineticLaw const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_hasRequiredElements" "', argument " "1"" of type '" "KineticLaw const *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (bool)((KineticLaw const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_removeFromParentAndDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_removeFromParentAndDelete" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  result = (int)(arg1)->removeFromParentAndDelete();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_renameSIdRefs" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KineticLaw_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_renameUnitSIdRefs" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KineticLaw_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_replaceSIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_replaceSIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_replaceSIDWithFunction" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KineticLaw_replaceSIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceSIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_divideAssignmentsToSIdByFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_divideAssignmentsToSIdByFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_divideAssignmentsToSIdByFunction" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_divideAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_divideAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KineticLaw_divideAssignmentsToSIdByFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->divideAssignmentsToSIdByFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_KineticLaw_multiplyAssignmentsToSIdByFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  KineticLaw *arg1 = (KineticLaw *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "KineticLaw_multiplyAssignmentsToSIdByFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KineticLaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KineticLaw_multiplyAssignmentsToSIdByFunction" "', argument " "1"" of type '" "KineticLaw *""'"); 
  }
  arg1 = reinterpret_cast< KineticLaw * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KineticLaw_multiplyAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KineticLaw_multiplyAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KineticLaw_multiplyAssignmentsToSIdByFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->multiplyAssignmentsToSIdByFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *KineticLaw_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_KineticLaw, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KineticLaw_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SimpleSpeciesReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SimpleSpeciesReference" "', argument " "1"" of type '" "SimpleSpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_getId" "', argument " "1"" of type '" "SimpleSpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  result = (std::string *) &((SimpleSpeciesReference const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_getName" "', argument " "1"" of type '" "SimpleSpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  result = (std::string *) &((SimpleSpeciesReference const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_getSpecies(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_getSpecies" "', argument " "1"" of type '" "SimpleSpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  result = (std::string *) &((SimpleSpeciesReference const *)arg1)->getSpecies();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_isSetId" "', argument " "1"" of type '" "SimpleSpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  result = (bool)((SimpleSpeciesReference const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_isSetName" "', argument " "1"" of type '" "SimpleSpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  result = (bool)((SimpleSpeciesReference const *)arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_isSetSpecies(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_isSetSpecies" "', argument " "1"" of type '" "SimpleSpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  result = (bool)((SimpleSpeciesReference const *)arg1)->isSetSpecies();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_setSpecies(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SimpleSpeciesReference_setSpecies", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_setSpecies" "', argument " "1"" of type '" "SimpleSpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleSpeciesReference_setSpecies" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleSpeciesReference_setSpecies" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setSpecies((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SimpleSpeciesReference_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_setId" "', argument " "1"" of type '" "SimpleSpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleSpeciesReference_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleSpeciesReference_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SimpleSpeciesReference_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_setName" "', argument " "1"" of type '" "SimpleSpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleSpeciesReference_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleSpeciesReference_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_unsetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_unsetId" "', argument " "1"" of type '" "SimpleSpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  result = (int)(arg1)->unsetId();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_unsetName" "', argument " "1"" of type '" "SimpleSpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_unsetSpecies(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_unsetSpecies" "', argument " "1"" of type '" "SimpleSpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  result = (int)(arg1)->unsetSpecies();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_isModifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_isModifier" "', argument " "1"" of type '" "SimpleSpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  result = (bool)((SimpleSpeciesReference const *)arg1)->isModifier();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleSpeciesReference_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SimpleSpeciesReference *arg1 = (SimpleSpeciesReference *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SimpleSpeciesReference_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpleSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleSpeciesReference_renameSIdRefs" "', argument " "1"" of type '" "SimpleSpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SimpleSpeciesReference * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleSpeciesReference_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleSpeciesReference_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SimpleSpeciesReference_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleSpeciesReference_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *SimpleSpeciesReference_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SimpleSpeciesReference, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SpeciesReference__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpeciesReference" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpeciesReference" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (SpeciesReference *)new SpeciesReference(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpeciesReference__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpeciesReference" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (SpeciesReference *)new SpeciesReference(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SpeciesReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpeciesReference" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpeciesReference__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SpeciesReference *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SpeciesReference,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpeciesReference" "', argument " "1"" of type '" "SpeciesReference const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpeciesReference" "', argument " "1"" of type '" "SpeciesReference const &""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  {
    try {
      result = (SpeciesReference *)new SpeciesReference((SpeciesReference const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpeciesReference(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SpeciesReference", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpeciesReference__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SpeciesReference, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpeciesReference__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SpeciesReference__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SpeciesReference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SpeciesReference::SpeciesReference(unsigned int,unsigned int)\n"
    "    SpeciesReference::SpeciesReference(SBMLNamespaces *)\n"
    "    SpeciesReference::SpeciesReference(SpeciesReference const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SpeciesReference *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_clone" "', argument " "1"" of type '" "SpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (SpeciesReference *)((SpeciesReference const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpeciesReference, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_initDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_initDefaults" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  (arg1)->initDefaults();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_getStoichiometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_getStoichiometry" "', argument " "1"" of type '" "SpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (double)((SpeciesReference const *)arg1)->getStoichiometry();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_getStoichiometryMath__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  StoichiometryMath *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_getStoichiometryMath" "', argument " "1"" of type '" "SpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (StoichiometryMath *)((SpeciesReference const *)arg1)->getStoichiometryMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_getStoichiometryMath__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  StoichiometryMath *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_getStoichiometryMath" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (StoichiometryMath *)(arg1)->getStoichiometryMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_getStoichiometryMath(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SpeciesReference_getStoichiometryMath", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SpeciesReference, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SpeciesReference_getStoichiometryMath__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SpeciesReference, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SpeciesReference_getStoichiometryMath__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SpeciesReference_getStoichiometryMath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SpeciesReference::getStoichiometryMath() const\n"
    "    SpeciesReference::getStoichiometryMath()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_getDenominator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_getDenominator" "', argument " "1"" of type '" "SpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (int)((SpeciesReference const *)arg1)->getDenominator();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_getConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_getConstant" "', argument " "1"" of type '" "SpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (bool)((SpeciesReference const *)arg1)->getConstant();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_isSetStoichiometryMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_isSetStoichiometryMath" "', argument " "1"" of type '" "SpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (bool)((SpeciesReference const *)arg1)->isSetStoichiometryMath();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_isSetConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_isSetConstant" "', argument " "1"" of type '" "SpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (bool)((SpeciesReference const *)arg1)->isSetConstant();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_isSetStoichiometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_isSetStoichiometry" "', argument " "1"" of type '" "SpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (bool)((SpeciesReference const *)arg1)->isSetStoichiometry();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_setStoichiometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SpeciesReference_setStoichiometry", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_setStoichiometry" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpeciesReference_setStoichiometry" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->setStoichiometry(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_setStoichiometryMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  StoichiometryMath *arg2 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SpeciesReference_setStoichiometryMath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_setStoichiometryMath" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpeciesReference_setStoichiometryMath" "', argument " "2"" of type '" "StoichiometryMath const *""'"); 
  }
  arg2 = reinterpret_cast< StoichiometryMath * >(argp2);
  result = (int)(arg1)->setStoichiometryMath((StoichiometryMath const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_setDenominator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SpeciesReference_setDenominator", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_setDenominator" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpeciesReference_setDenominator" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->setDenominator(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_setConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SpeciesReference_setConstant", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_setConstant" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpeciesReference_setConstant" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setConstant(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_unsetStoichiometryMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_unsetStoichiometryMath" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (int)(arg1)->unsetStoichiometryMath();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_unsetStoichiometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_unsetStoichiometry" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (int)(arg1)->unsetStoichiometry();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_unsetConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_unsetConstant" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (int)(arg1)->unsetConstant();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_createStoichiometryMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StoichiometryMath *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_createStoichiometryMath" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (StoichiometryMath *)(arg1)->createStoichiometryMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_setAnnotation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_setAnnotation" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpeciesReference_setAnnotation" "', argument " "2"" of type '" "XMLNode const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  result = (int)(arg1)->setAnnotation((XMLNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_setAnnotation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_setAnnotation" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpeciesReference_setAnnotation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpeciesReference_setAnnotation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setAnnotation((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_setAnnotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SpeciesReference_setAnnotation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SpeciesReference, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpeciesReference_setAnnotation__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SpeciesReference, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpeciesReference_setAnnotation__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SpeciesReference_setAnnotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SpeciesReference::setAnnotation(XMLNode const *)\n"
    "    SpeciesReference::setAnnotation(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_appendAnnotation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_appendAnnotation" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpeciesReference_appendAnnotation" "', argument " "2"" of type '" "XMLNode const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  result = (int)(arg1)->appendAnnotation((XMLNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_appendAnnotation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_appendAnnotation" "', argument " "1"" of type '" "SpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpeciesReference_appendAnnotation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpeciesReference_appendAnnotation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->appendAnnotation((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_appendAnnotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SpeciesReference_appendAnnotation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SpeciesReference, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpeciesReference_appendAnnotation__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SpeciesReference, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpeciesReference_appendAnnotation__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SpeciesReference_appendAnnotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SpeciesReference::appendAnnotation(XMLNode const *)\n"
    "    SpeciesReference::appendAnnotation(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_getTypeCode" "', argument " "1"" of type '" "SpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (int)((SpeciesReference const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_getElementName" "', argument " "1"" of type '" "SpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (std::string *) &((SpeciesReference const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpeciesReference_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpeciesReference *arg1 = (SpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpeciesReference_hasRequiredAttributes" "', argument " "1"" of type '" "SpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< SpeciesReference * >(argp1);
  result = (bool)((SpeciesReference const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SpeciesReference_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SpeciesReference, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SpeciesReference_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfSpeciesReferences__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfSpeciesReferences *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfSpeciesReferences" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfSpeciesReferences" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfSpeciesReferences *)new ListOfSpeciesReferences(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesReferences, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfSpeciesReferences__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfSpeciesReferences *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfSpeciesReferences" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfSpeciesReferences *)new ListOfSpeciesReferences(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesReferences, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfSpeciesReferences(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfSpeciesReferences", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfSpeciesReferences__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfSpeciesReferences__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfSpeciesReferences'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfSpeciesReferences::ListOfSpeciesReferences(unsigned int,unsigned int)\n"
    "    ListOfSpeciesReferences::ListOfSpeciesReferences(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesReferences_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfSpeciesReferences *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesReferences_clone" "', argument " "1"" of type '" "ListOfSpeciesReferences const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesReferences * >(argp1);
  result = (ListOfSpeciesReferences *)((ListOfSpeciesReferences const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfSpeciesReferences, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesReferences_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesReferences_getItemTypeCode" "', argument " "1"" of type '" "ListOfSpeciesReferences const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesReferences * >(argp1);
  result = (int)((ListOfSpeciesReferences const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesReferences_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesReferences_getElementName" "', argument " "1"" of type '" "ListOfSpeciesReferences const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesReferences * >(argp1);
  result = (std::string *) &((ListOfSpeciesReferences const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesReferences_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SimpleSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesReferences_get" "', argument " "1"" of type '" "ListOfSpeciesReferences *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesReferences * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfSpeciesReferences_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SimpleSpeciesReference *)(arg1)->get(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesReferences_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SimpleSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesReferences_get" "', argument " "1"" of type '" "ListOfSpeciesReferences const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesReferences * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfSpeciesReferences_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SimpleSpeciesReference *)((ListOfSpeciesReferences const *)arg1)->get(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesReferences_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SimpleSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesReferences_get" "', argument " "1"" of type '" "ListOfSpeciesReferences *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesReferences * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfSpeciesReferences_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfSpeciesReferences_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SimpleSpeciesReference *)(arg1)->get((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesReferences_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SimpleSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesReferences_get" "', argument " "1"" of type '" "ListOfSpeciesReferences const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesReferences * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfSpeciesReferences_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfSpeciesReferences_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SimpleSpeciesReference *)((ListOfSpeciesReferences const *)arg1)->get((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesReferences_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfSpeciesReferences_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpeciesReferences, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfSpeciesReferences_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpeciesReferences, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfSpeciesReferences_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpeciesReferences, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfSpeciesReferences_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpeciesReferences, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfSpeciesReferences_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfSpeciesReferences_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfSpeciesReferences::get(unsigned int)\n"
    "    ListOfSpeciesReferences::get(unsigned int) const\n"
    "    ListOfSpeciesReferences::get(std::string const &)\n"
    "    ListOfSpeciesReferences::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesReferences_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SimpleSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesReferences_remove" "', argument " "1"" of type '" "ListOfSpeciesReferences *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesReferences * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfSpeciesReferences_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SimpleSpeciesReference *)(arg1)->remove(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesReferences_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SimpleSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesReferences_remove" "', argument " "1"" of type '" "ListOfSpeciesReferences *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesReferences * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfSpeciesReferences_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfSpeciesReferences_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SimpleSpeciesReference *)(arg1)->remove((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesReferences_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfSpeciesReferences_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpeciesReferences, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfSpeciesReferences_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfSpeciesReferences, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfSpeciesReferences_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfSpeciesReferences_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfSpeciesReferences::remove(unsigned int)\n"
    "    ListOfSpeciesReferences::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfSpeciesReferences_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesReferences, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfSpeciesReferences_getType" "', argument " "1"" of type '" "ListOfSpeciesReferences const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesReferences * >(argp1);
  result = (unsigned int)((ListOfSpeciesReferences const *)arg1)->getType();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListOfSpeciesReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfSpeciesReferences *arg1 = (ListOfSpeciesReferences *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfSpeciesReferences, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfSpeciesReferences" "', argument " "1"" of type '" "ListOfSpeciesReferences *""'"); 
  }
  arg1 = reinterpret_cast< ListOfSpeciesReferences * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfSpeciesReferences_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfSpeciesReferences, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfSpeciesReferences_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ModifierSpeciesReference__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ModifierSpeciesReference *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ModifierSpeciesReference" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ModifierSpeciesReference" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ModifierSpeciesReference *)new ModifierSpeciesReference(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModifierSpeciesReference__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ModifierSpeciesReference *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ModifierSpeciesReference" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ModifierSpeciesReference *)new ModifierSpeciesReference(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModifierSpeciesReference(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ModifierSpeciesReference", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ModifierSpeciesReference__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ModifierSpeciesReference__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ModifierSpeciesReference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ModifierSpeciesReference::ModifierSpeciesReference(unsigned int,unsigned int)\n"
    "    ModifierSpeciesReference::ModifierSpeciesReference(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ModifierSpeciesReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModifierSpeciesReference *arg1 = (ModifierSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModifierSpeciesReference, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModifierSpeciesReference" "', argument " "1"" of type '" "ModifierSpeciesReference *""'"); 
  }
  arg1 = reinterpret_cast< ModifierSpeciesReference * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModifierSpeciesReference_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModifierSpeciesReference *arg1 = (ModifierSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ModifierSpeciesReference *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModifierSpeciesReference_clone" "', argument " "1"" of type '" "ModifierSpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< ModifierSpeciesReference * >(argp1);
  result = (ModifierSpeciesReference *)((ModifierSpeciesReference const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModifierSpeciesReference, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModifierSpeciesReference_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModifierSpeciesReference *arg1 = (ModifierSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModifierSpeciesReference_getTypeCode" "', argument " "1"" of type '" "ModifierSpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< ModifierSpeciesReference * >(argp1);
  result = (int)((ModifierSpeciesReference const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModifierSpeciesReference_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModifierSpeciesReference *arg1 = (ModifierSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModifierSpeciesReference_getElementName" "', argument " "1"" of type '" "ModifierSpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< ModifierSpeciesReference * >(argp1);
  result = (std::string *) &((ModifierSpeciesReference const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModifierSpeciesReference_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModifierSpeciesReference *arg1 = (ModifierSpeciesReference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModifierSpeciesReference, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModifierSpeciesReference_hasRequiredAttributes" "', argument " "1"" of type '" "ModifierSpeciesReference const *""'"); 
  }
  arg1 = reinterpret_cast< ModifierSpeciesReference * >(argp1);
  result = (bool)((ModifierSpeciesReference const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ModifierSpeciesReference_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ModifierSpeciesReference, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ModifierSpeciesReference_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Event__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Event" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Event" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Event *)new Event(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Event__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Event *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Event" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (Event *)new Event(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Event__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Event *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Event,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Event" "', argument " "1"" of type '" "Event const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Event" "', argument " "1"" of type '" "Event const &""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  {
    try {
      result = (Event *)new Event((Event const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Event(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Event", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Event__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Event, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Event__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Event__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Event'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Event::Event(unsigned int,unsigned int)\n"
    "    Event::Event(SBMLNamespaces *)\n"
    "    Event::Event(Event const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Event *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_clone" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (Event *)((Event const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_initDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_initDefaults" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  (arg1)->initDefaults();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Event_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getElementBySId" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getElementByMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Event_getElementByMetaId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getElementByMetaId" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementByMetaId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getId" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (std::string *) &((Event const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getName" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (std::string *) &((Event const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getTrigger__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Trigger *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getTrigger" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (Trigger *)((Event const *)arg1)->getTrigger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Trigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getTrigger__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Trigger *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getTrigger" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (Trigger *)(arg1)->getTrigger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Trigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getTrigger(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Event_getTrigger", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_getTrigger__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_getTrigger__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Event_getTrigger'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Event::getTrigger() const\n"
    "    Event::getTrigger()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_getDelay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Delay *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getDelay" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (Delay *)((Event const *)arg1)->getDelay();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Delay, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getDelay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Delay *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getDelay" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (Delay *)(arg1)->getDelay();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Delay, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getDelay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Event_getDelay", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_getDelay__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_getDelay__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Event_getDelay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Event::getDelay() const\n"
    "    Event::getDelay()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_getPriority__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Priority *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getPriority" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (Priority *)((Event const *)arg1)->getPriority();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Priority, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getPriority__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Priority *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getPriority" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (Priority *)(arg1)->getPriority();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Priority, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getPriority(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Event_getPriority", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_getPriority__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_getPriority__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Event_getPriority'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Event::getPriority() const\n"
    "    Event::getPriority()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_getTimeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getTimeUnits" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (std::string *) &((Event const *)arg1)->getTimeUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getUseValuesFromTriggerTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getUseValuesFromTriggerTime" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (bool)((Event const *)arg1)->getUseValuesFromTriggerTime();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_isSetId" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (bool)((Event const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_isSetName" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (bool)((Event const *)arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_isSetTrigger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_isSetTrigger" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (bool)((Event const *)arg1)->isSetTrigger();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_isSetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_isSetDelay" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (bool)((Event const *)arg1)->isSetDelay();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_isSetPriority(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_isSetPriority" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (bool)((Event const *)arg1)->isSetPriority();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_isSetTimeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_isSetTimeUnits" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (bool)((Event const *)arg1)->isSetTimeUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_isSetUseValuesFromTriggerTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_isSetUseValuesFromTriggerTime" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (bool)((Event const *)arg1)->isSetUseValuesFromTriggerTime();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Event_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setId" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Event_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setName" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_setTrigger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  Trigger *arg2 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Event_setTrigger", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setTrigger" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_setTrigger" "', argument " "2"" of type '" "Trigger const *""'"); 
  }
  arg2 = reinterpret_cast< Trigger * >(argp2);
  result = (int)(arg1)->setTrigger((Trigger const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_setDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  Delay *arg2 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Event_setDelay", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setDelay" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_setDelay" "', argument " "2"" of type '" "Delay const *""'"); 
  }
  arg2 = reinterpret_cast< Delay * >(argp2);
  result = (int)(arg1)->setDelay((Delay const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_setPriority(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  Priority *arg2 = (Priority *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Event_setPriority", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setPriority" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Priority, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_setPriority" "', argument " "2"" of type '" "Priority const *""'"); 
  }
  arg2 = reinterpret_cast< Priority * >(argp2);
  result = (int)(arg1)->setPriority((Priority const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_setTimeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Event_setTimeUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setTimeUnits" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_setTimeUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_setTimeUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setTimeUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_setUseValuesFromTriggerTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Event_setUseValuesFromTriggerTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setUseValuesFromTriggerTime" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_setUseValuesFromTriggerTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setUseValuesFromTriggerTime(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_unsetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_unsetId" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (int)(arg1)->unsetId();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_unsetName" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_unsetUseValuesFromTriggerTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_unsetUseValuesFromTriggerTime" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (int)(arg1)->unsetUseValuesFromTriggerTime();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_unsetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_unsetDelay" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (int)(arg1)->unsetDelay();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_unsetPriority(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_unsetPriority" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (int)(arg1)->unsetPriority();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_unsetTrigger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_unsetTrigger" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (int)(arg1)->unsetTrigger();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_unsetTimeUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_unsetTimeUnits" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (int)(arg1)->unsetTimeUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_addEventAssignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  EventAssignment *arg2 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Event_addEventAssignment", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_addEventAssignment" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_addEventAssignment" "', argument " "2"" of type '" "EventAssignment const *""'"); 
  }
  arg2 = reinterpret_cast< EventAssignment * >(argp2);
  result = (int)(arg1)->addEventAssignment((EventAssignment const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_createEventAssignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  EventAssignment *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_createEventAssignment" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (EventAssignment *)(arg1)->createEventAssignment();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_createTrigger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Trigger *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_createTrigger" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (Trigger *)(arg1)->createTrigger();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Trigger, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_createDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Delay *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_createDelay" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (Delay *)(arg1)->createDelay();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Delay, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_createPriority(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Priority *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_createPriority" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (Priority *)(arg1)->createPriority();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Priority, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getListOfEventAssignments__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfEventAssignments *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getListOfEventAssignments" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (ListOfEventAssignments *)((Event const *)arg1)->getListOfEventAssignments();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfEventAssignments, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getListOfEventAssignments__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfEventAssignments *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getListOfEventAssignments" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (ListOfEventAssignments *)(arg1)->getListOfEventAssignments();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfEventAssignments, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getListOfEventAssignments(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Event_getListOfEventAssignments", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_getListOfEventAssignments__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_getListOfEventAssignments__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Event_getListOfEventAssignments'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Event::getListOfEventAssignments() const\n"
    "    Event::getListOfEventAssignments()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_getEventAssignment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getEventAssignment" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_getEventAssignment" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (EventAssignment *)((Event const *)arg1)->getEventAssignment(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getEventAssignment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getEventAssignment" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_getEventAssignment" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (EventAssignment *)(arg1)->getEventAssignment(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getEventAssignment__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getEventAssignment" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_getEventAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_getEventAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (EventAssignment *)((Event const *)arg1)->getEventAssignment((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getEventAssignment__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getEventAssignment" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_getEventAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_getEventAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (EventAssignment *)(arg1)->getEventAssignment((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getEventAssignment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Event_getEventAssignment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Event_getEventAssignment__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Event_getEventAssignment__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Event_getEventAssignment__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Event_getEventAssignment__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Event_getEventAssignment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Event::getEventAssignment(unsigned int) const\n"
    "    Event::getEventAssignment(unsigned int)\n"
    "    Event::getEventAssignment(std::string const &) const\n"
    "    Event::getEventAssignment(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_getNumEventAssignments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getNumEventAssignments" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (unsigned int)((Event const *)arg1)->getNumEventAssignments();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_removeEventAssignment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_removeEventAssignment" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_removeEventAssignment" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (EventAssignment *)(arg1)->removeEventAssignment(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_removeEventAssignment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_removeEventAssignment" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_removeEventAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_removeEventAssignment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (EventAssignment *)(arg1)->removeEventAssignment((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_removeEventAssignment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Event_removeEventAssignment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Event_removeEventAssignment__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Event_removeEventAssignment__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Event_removeEventAssignment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Event::removeEventAssignment(unsigned int)\n"
    "    Event::removeEventAssignment(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_connectToChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_connectToChild" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  (arg1)->connectToChild();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_enablePackageInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Event_enablePackageInternal", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_enablePackageInternal" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Event_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_enablePackageInternal" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->enablePackageInternal((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_updateSBMLNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Event_updateSBMLNamespace", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_updateSBMLNamespace" "', argument " "1"" of type '" "Event *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_updateSBMLNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_updateSBMLNamespace" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  (arg1)->updateSBMLNamespace((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getTypeCode" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (int)((Event const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getElementName" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (std::string *) &((Event const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_hasRequiredAttributes" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (bool)((Event const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Event *arg1 = (Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_hasRequiredElements" "', argument " "1"" of type '" "Event const *""'"); 
  }
  arg1 = reinterpret_cast< Event * >(argp1);
  result = (bool)((Event const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Event, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Event_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfEvents__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfEvents *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfEvents" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfEvents" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfEvents *)new ListOfEvents(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfEvents, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfEvents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfEvents *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfEvents" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfEvents *)new ListOfEvents(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfEvents, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfEvents(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfEvents", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfEvents__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfEvents__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfEvents'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfEvents::ListOfEvents(unsigned int,unsigned int)\n"
    "    ListOfEvents::ListOfEvents(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfEvents_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfEvents *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEvents, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEvents_clone" "', argument " "1"" of type '" "ListOfEvents const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEvents * >(argp1);
  result = (ListOfEvents *)((ListOfEvents const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfEvents, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEvents_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEvents, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEvents_getItemTypeCode" "', argument " "1"" of type '" "ListOfEvents const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEvents * >(argp1);
  result = (int)((ListOfEvents const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEvents_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEvents, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEvents_getElementName" "', argument " "1"" of type '" "ListOfEvents const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEvents * >(argp1);
  result = (std::string *) &((ListOfEvents const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEvents_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEvents, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEvents_get" "', argument " "1"" of type '" "ListOfEvents *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEvents * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfEvents_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Event *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEvents_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEvents, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEvents_get" "', argument " "1"" of type '" "ListOfEvents const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEvents * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfEvents_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Event *)((ListOfEvents const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEvents_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEvents, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEvents_get" "', argument " "1"" of type '" "ListOfEvents *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEvents * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfEvents_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfEvents_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Event *)(arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEvents_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEvents, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEvents_get" "', argument " "1"" of type '" "ListOfEvents const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEvents * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfEvents_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfEvents_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Event *)((ListOfEvents const *)arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEvents_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfEvents_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfEvents, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfEvents_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfEvents, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfEvents_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfEvents, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfEvents_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfEvents, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfEvents_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfEvents_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfEvents::get(unsigned int)\n"
    "    ListOfEvents::get(unsigned int) const\n"
    "    ListOfEvents::get(std::string const &)\n"
    "    ListOfEvents::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfEvents_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEvents, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEvents_remove" "', argument " "1"" of type '" "ListOfEvents *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEvents * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfEvents_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Event *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEvents_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Event *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEvents, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEvents_remove" "', argument " "1"" of type '" "ListOfEvents *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEvents * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfEvents_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfEvents_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (Event *)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEvents_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfEvents_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfEvents, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfEvents_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfEvents, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfEvents_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfEvents_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfEvents::remove(unsigned int)\n"
    "    ListOfEvents::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListOfEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfEvents *arg1 = (ListOfEvents *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEvents, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfEvents" "', argument " "1"" of type '" "ListOfEvents *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEvents * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfEvents_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfEvents, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfEvents_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EventAssignment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EventAssignment" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventAssignment" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (EventAssignment *)new EventAssignment(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventAssignment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventAssignment" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (EventAssignment *)new EventAssignment(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EventAssignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventAssignment" "', argument " "1"" of type '" "EventAssignment *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventAssignment__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_EventAssignment,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventAssignment" "', argument " "1"" of type '" "EventAssignment const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EventAssignment" "', argument " "1"" of type '" "EventAssignment const &""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  {
    try {
      result = (EventAssignment *)new EventAssignment((EventAssignment const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventAssignment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EventAssignment", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EventAssignment__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_EventAssignment, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EventAssignment__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_EventAssignment__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EventAssignment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EventAssignment::EventAssignment(unsigned int,unsigned int)\n"
    "    EventAssignment::EventAssignment(SBMLNamespaces *)\n"
    "    EventAssignment::EventAssignment(EventAssignment const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_EventAssignment_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  EventAssignment *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_clone" "', argument " "1"" of type '" "EventAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (EventAssignment *)((EventAssignment const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_getVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_getVariable" "', argument " "1"" of type '" "EventAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (std::string *) &((EventAssignment const *)arg1)->getVariable();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_getMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_getMath" "', argument " "1"" of type '" "EventAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (ASTNode *)((EventAssignment const *)arg1)->getMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_isSetVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_isSetVariable" "', argument " "1"" of type '" "EventAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (bool)((EventAssignment const *)arg1)->isSetVariable();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_isSetMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_isSetMath" "', argument " "1"" of type '" "EventAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (bool)((EventAssignment const *)arg1)->isSetMath();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_setVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "EventAssignment_setVariable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_setVariable" "', argument " "1"" of type '" "EventAssignment *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventAssignment_setVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EventAssignment_setVariable" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setVariable((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_unsetVariable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_unsetVariable" "', argument " "1"" of type '" "EventAssignment *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (int)(arg1)->unsetVariable();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_setMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "EventAssignment_setMath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_setMath" "', argument " "1"" of type '" "EventAssignment *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventAssignment_setMath" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (int)(arg1)->setMath((ASTNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_getDerivedUnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_getDerivedUnitDefinition" "', argument " "1"" of type '" "EventAssignment *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_getDerivedUnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_getDerivedUnitDefinition" "', argument " "1"" of type '" "EventAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (UnitDefinition *)((EventAssignment const *)arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_getDerivedUnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "EventAssignment_getDerivedUnitDefinition", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EventAssignment, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_EventAssignment_getDerivedUnitDefinition__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EventAssignment, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_EventAssignment_getDerivedUnitDefinition__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'EventAssignment_getDerivedUnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EventAssignment::getDerivedUnitDefinition()\n"
    "    EventAssignment::getDerivedUnitDefinition() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_EventAssignment_containsUndeclaredUnits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_containsUndeclaredUnits" "', argument " "1"" of type '" "EventAssignment *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (bool)(arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_containsUndeclaredUnits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_containsUndeclaredUnits" "', argument " "1"" of type '" "EventAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (bool)((EventAssignment const *)arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_containsUndeclaredUnits(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "EventAssignment_containsUndeclaredUnits", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EventAssignment, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_EventAssignment_containsUndeclaredUnits__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EventAssignment, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_EventAssignment_containsUndeclaredUnits__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'EventAssignment_containsUndeclaredUnits'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EventAssignment::containsUndeclaredUnits()\n"
    "    EventAssignment::containsUndeclaredUnits() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_EventAssignment_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_getTypeCode" "', argument " "1"" of type '" "EventAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (int)((EventAssignment const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_getElementName" "', argument " "1"" of type '" "EventAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (std::string *) &((EventAssignment const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_hasRequiredAttributes" "', argument " "1"" of type '" "EventAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (bool)((EventAssignment const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_hasRequiredElements" "', argument " "1"" of type '" "EventAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (bool)((EventAssignment const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_getId" "', argument " "1"" of type '" "EventAssignment const *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  result = (std::string *) &((EventAssignment const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "EventAssignment_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_renameSIdRefs" "', argument " "1"" of type '" "EventAssignment *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventAssignment_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EventAssignment_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EventAssignment_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EventAssignment_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "EventAssignment_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_renameUnitSIdRefs" "', argument " "1"" of type '" "EventAssignment *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventAssignment_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EventAssignment_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EventAssignment_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EventAssignment_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_replaceSIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "EventAssignment_replaceSIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_replaceSIDWithFunction" "', argument " "1"" of type '" "EventAssignment *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventAssignment_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EventAssignment_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EventAssignment_replaceSIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceSIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_divideAssignmentsToSIdByFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "EventAssignment_divideAssignmentsToSIdByFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_divideAssignmentsToSIdByFunction" "', argument " "1"" of type '" "EventAssignment *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventAssignment_divideAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EventAssignment_divideAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EventAssignment_divideAssignmentsToSIdByFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->divideAssignmentsToSIdByFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventAssignment_multiplyAssignmentsToSIdByFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  EventAssignment *arg1 = (EventAssignment *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "EventAssignment_multiplyAssignmentsToSIdByFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventAssignment_multiplyAssignmentsToSIdByFunction" "', argument " "1"" of type '" "EventAssignment *""'"); 
  }
  arg1 = reinterpret_cast< EventAssignment * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventAssignment_multiplyAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EventAssignment_multiplyAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EventAssignment_multiplyAssignmentsToSIdByFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->multiplyAssignmentsToSIdByFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *EventAssignment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_EventAssignment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EventAssignment_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ListOfEventAssignments__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ListOfEventAssignments *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ListOfEventAssignments" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ListOfEventAssignments" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (ListOfEventAssignments *)new ListOfEventAssignments(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfEventAssignments, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfEventAssignments__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListOfEventAssignments *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOfEventAssignments" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (ListOfEventAssignments *)new ListOfEventAssignments(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfEventAssignments, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOfEventAssignments(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ListOfEventAssignments", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOfEventAssignments__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ListOfEventAssignments__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ListOfEventAssignments'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfEventAssignments::ListOfEventAssignments(unsigned int,unsigned int)\n"
    "    ListOfEventAssignments::ListOfEventAssignments(SBMLNamespaces *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfEventAssignments_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListOfEventAssignments *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEventAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEventAssignments_clone" "', argument " "1"" of type '" "ListOfEventAssignments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEventAssignments * >(argp1);
  result = (ListOfEventAssignments *)((ListOfEventAssignments const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ListOfEventAssignments, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEventAssignments_getItemTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEventAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEventAssignments_getItemTypeCode" "', argument " "1"" of type '" "ListOfEventAssignments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEventAssignments * >(argp1);
  result = (int)((ListOfEventAssignments const *)arg1)->getItemTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEventAssignments_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEventAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEventAssignments_getElementName" "', argument " "1"" of type '" "ListOfEventAssignments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEventAssignments * >(argp1);
  result = (std::string *) &((ListOfEventAssignments const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEventAssignments_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEventAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEventAssignments_get" "', argument " "1"" of type '" "ListOfEventAssignments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEventAssignments * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfEventAssignments_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (EventAssignment *)(arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEventAssignments_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEventAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEventAssignments_get" "', argument " "1"" of type '" "ListOfEventAssignments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEventAssignments * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfEventAssignments_get" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (EventAssignment *)((ListOfEventAssignments const *)arg1)->get(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEventAssignments_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEventAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEventAssignments_get" "', argument " "1"" of type '" "ListOfEventAssignments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEventAssignments * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfEventAssignments_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfEventAssignments_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (EventAssignment *)(arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEventAssignments_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEventAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEventAssignments_get" "', argument " "1"" of type '" "ListOfEventAssignments const *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEventAssignments * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfEventAssignments_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfEventAssignments_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (EventAssignment *)((ListOfEventAssignments const *)arg1)->get((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEventAssignments_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfEventAssignments_get", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfEventAssignments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfEventAssignments_get__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfEventAssignments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfEventAssignments_get__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfEventAssignments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfEventAssignments_get__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfEventAssignments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfEventAssignments_get__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfEventAssignments_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfEventAssignments::get(unsigned int)\n"
    "    ListOfEventAssignments::get(unsigned int) const\n"
    "    ListOfEventAssignments::get(std::string const &)\n"
    "    ListOfEventAssignments::get(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfEventAssignments_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEventAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEventAssignments_remove" "', argument " "1"" of type '" "ListOfEventAssignments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEventAssignments * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ListOfEventAssignments_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (EventAssignment *)(arg1)->remove(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEventAssignments_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  EventAssignment *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEventAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEventAssignments_remove" "', argument " "1"" of type '" "ListOfEventAssignments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEventAssignments * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfEventAssignments_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfEventAssignments_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (EventAssignment *)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EventAssignment, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ListOfEventAssignments_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ListOfEventAssignments_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfEventAssignments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ListOfEventAssignments_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ListOfEventAssignments, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ListOfEventAssignments_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ListOfEventAssignments_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ListOfEventAssignments::remove(unsigned int)\n"
    "    ListOfEventAssignments::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ListOfEventAssignments_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ListOfEventAssignments_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEventAssignments, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfEventAssignments_getElementBySId" "', argument " "1"" of type '" "ListOfEventAssignments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEventAssignments * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfEventAssignments_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListOfEventAssignments_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ListOfEventAssignments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ListOfEventAssignments *arg1 = (ListOfEventAssignments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ListOfEventAssignments, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOfEventAssignments" "', argument " "1"" of type '" "ListOfEventAssignments *""'"); 
  }
  arg1 = reinterpret_cast< ListOfEventAssignments * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOfEventAssignments_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ListOfEventAssignments, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ListOfEventAssignments_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Trigger__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Trigger *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Trigger" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Trigger" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Trigger *)new Trigger(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Trigger, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Trigger__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Trigger *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Trigger" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (Trigger *)new Trigger(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Trigger, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Trigger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Trigger" "', argument " "1"" of type '" "Trigger *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Trigger__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Trigger *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Trigger *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Trigger,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Trigger" "', argument " "1"" of type '" "Trigger const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Trigger" "', argument " "1"" of type '" "Trigger const &""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  {
    try {
      result = (Trigger *)new Trigger((Trigger const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Trigger, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Trigger(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Trigger", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Trigger__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Trigger, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Trigger__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Trigger__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Trigger'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Trigger::Trigger(unsigned int,unsigned int)\n"
    "    Trigger::Trigger(SBMLNamespaces *)\n"
    "    Trigger::Trigger(Trigger const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Trigger_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Trigger *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_clone" "', argument " "1"" of type '" "Trigger const *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (Trigger *)((Trigger const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Trigger, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_getMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_getMath" "', argument " "1"" of type '" "Trigger const *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (ASTNode *)((Trigger const *)arg1)->getMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_getInitialValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_getInitialValue" "', argument " "1"" of type '" "Trigger const *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (bool)((Trigger const *)arg1)->getInitialValue();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_getPersistent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_getPersistent" "', argument " "1"" of type '" "Trigger const *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (bool)((Trigger const *)arg1)->getPersistent();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_isSetMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_isSetMath" "', argument " "1"" of type '" "Trigger const *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (bool)((Trigger const *)arg1)->isSetMath();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_isSetInitialValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_isSetInitialValue" "', argument " "1"" of type '" "Trigger const *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (bool)((Trigger const *)arg1)->isSetInitialValue();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_isSetPersistent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_isSetPersistent" "', argument " "1"" of type '" "Trigger const *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (bool)((Trigger const *)arg1)->isSetPersistent();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_setMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Trigger_setMath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_setMath" "', argument " "1"" of type '" "Trigger *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Trigger_setMath" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (int)(arg1)->setMath((ASTNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_setInitialValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Trigger_setInitialValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_setInitialValue" "', argument " "1"" of type '" "Trigger *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Trigger_setInitialValue" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setInitialValue(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_setPersistent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Trigger_setPersistent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_setPersistent" "', argument " "1"" of type '" "Trigger *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Trigger_setPersistent" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setPersistent(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_unsetInitialValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_unsetInitialValue" "', argument " "1"" of type '" "Trigger *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (int)(arg1)->unsetInitialValue();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_unsetPersistent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_unsetPersistent" "', argument " "1"" of type '" "Trigger *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (int)(arg1)->unsetPersistent();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_getTypeCode" "', argument " "1"" of type '" "Trigger const *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (int)((Trigger const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_getElementName" "', argument " "1"" of type '" "Trigger const *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (std::string *) &((Trigger const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Trigger_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_renameSIdRefs" "', argument " "1"" of type '" "Trigger *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Trigger_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Trigger_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Trigger_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Trigger_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Trigger_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_renameUnitSIdRefs" "', argument " "1"" of type '" "Trigger *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Trigger_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Trigger_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Trigger_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Trigger_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_replaceSIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Trigger_replaceSIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_replaceSIDWithFunction" "', argument " "1"" of type '" "Trigger *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Trigger_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Trigger_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Trigger_replaceSIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceSIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_hasRequiredElements" "', argument " "1"" of type '" "Trigger const *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (bool)((Trigger const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_hasRequiredAttributes" "', argument " "1"" of type '" "Trigger const *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (bool)((Trigger const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Trigger_removeFromParentAndDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Trigger *arg1 = (Trigger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Trigger, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Trigger_removeFromParentAndDelete" "', argument " "1"" of type '" "Trigger *""'"); 
  }
  arg1 = reinterpret_cast< Trigger * >(argp1);
  result = (int)(arg1)->removeFromParentAndDelete();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Trigger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Trigger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Trigger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Delay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Delay *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Delay" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Delay" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Delay *)new Delay(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Delay, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Delay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Delay *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Delay" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (Delay *)new Delay(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Delay, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Delay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Delay" "', argument " "1"" of type '" "Delay *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Delay__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Delay *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Delay *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Delay,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Delay" "', argument " "1"" of type '" "Delay const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Delay" "', argument " "1"" of type '" "Delay const &""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  {
    try {
      result = (Delay *)new Delay((Delay const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Delay, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Delay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Delay", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Delay__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Delay, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Delay__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Delay__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Delay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Delay::Delay(unsigned int,unsigned int)\n"
    "    Delay::Delay(SBMLNamespaces *)\n"
    "    Delay::Delay(Delay const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Delay_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Delay *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_clone" "', argument " "1"" of type '" "Delay const *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  result = (Delay *)((Delay const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Delay, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_getMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_getMath" "', argument " "1"" of type '" "Delay const *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  result = (ASTNode *)((Delay const *)arg1)->getMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_isSetMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_isSetMath" "', argument " "1"" of type '" "Delay const *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  result = (bool)((Delay const *)arg1)->isSetMath();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_setMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Delay_setMath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_setMath" "', argument " "1"" of type '" "Delay *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Delay_setMath" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (int)(arg1)->setMath((ASTNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_getDerivedUnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_getDerivedUnitDefinition" "', argument " "1"" of type '" "Delay *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_getDerivedUnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_getDerivedUnitDefinition" "', argument " "1"" of type '" "Delay const *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  result = (UnitDefinition *)((Delay const *)arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_getDerivedUnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Delay_getDerivedUnitDefinition", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Delay, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Delay_getDerivedUnitDefinition__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Delay, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Delay_getDerivedUnitDefinition__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Delay_getDerivedUnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Delay::getDerivedUnitDefinition()\n"
    "    Delay::getDerivedUnitDefinition() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Delay_containsUndeclaredUnits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_containsUndeclaredUnits" "', argument " "1"" of type '" "Delay *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  result = (bool)(arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_containsUndeclaredUnits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_containsUndeclaredUnits" "', argument " "1"" of type '" "Delay const *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  result = (bool)((Delay const *)arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_containsUndeclaredUnits(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Delay_containsUndeclaredUnits", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Delay, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Delay_containsUndeclaredUnits__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Delay, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Delay_containsUndeclaredUnits__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Delay_containsUndeclaredUnits'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Delay::containsUndeclaredUnits()\n"
    "    Delay::containsUndeclaredUnits() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Delay_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_getTypeCode" "', argument " "1"" of type '" "Delay const *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  result = (int)((Delay const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_getElementName" "', argument " "1"" of type '" "Delay const *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  result = (std::string *) &((Delay const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_hasRequiredElements" "', argument " "1"" of type '" "Delay const *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  result = (bool)((Delay const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_removeFromParentAndDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_removeFromParentAndDelete" "', argument " "1"" of type '" "Delay *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  result = (int)(arg1)->removeFromParentAndDelete();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Delay_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_renameSIdRefs" "', argument " "1"" of type '" "Delay *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Delay_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Delay_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Delay_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Delay_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Delay_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_renameUnitSIdRefs" "', argument " "1"" of type '" "Delay *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Delay_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Delay_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Delay_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Delay_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Delay_replaceSIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Delay *arg1 = (Delay *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Delay_replaceSIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Delay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Delay_replaceSIDWithFunction" "', argument " "1"" of type '" "Delay *""'"); 
  }
  arg1 = reinterpret_cast< Delay * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Delay_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Delay_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Delay_replaceSIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceSIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *Delay_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Delay, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Delay_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Priority__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Priority *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Priority" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Priority" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Priority *)new Priority(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Priority, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Priority__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Priority *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Priority" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (Priority *)new Priority(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Priority, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Priority(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Priority *arg1 = (Priority *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Priority, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Priority" "', argument " "1"" of type '" "Priority *""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Priority__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Priority *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Priority *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Priority,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Priority" "', argument " "1"" of type '" "Priority const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Priority" "', argument " "1"" of type '" "Priority const &""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  {
    try {
      result = (Priority *)new Priority((Priority const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Priority, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Priority(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Priority", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Priority__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Priority, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Priority__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Priority__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Priority'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Priority::Priority(unsigned int,unsigned int)\n"
    "    Priority::Priority(SBMLNamespaces *)\n"
    "    Priority::Priority(Priority const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Priority_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Priority *arg1 = (Priority *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Priority *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Priority, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Priority_clone" "', argument " "1"" of type '" "Priority const *""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  result = (Priority *)((Priority const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Priority, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Priority_getMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Priority *arg1 = (Priority *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Priority, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Priority_getMath" "', argument " "1"" of type '" "Priority const *""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  result = (ASTNode *)((Priority const *)arg1)->getMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Priority_isSetMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Priority *arg1 = (Priority *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Priority, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Priority_isSetMath" "', argument " "1"" of type '" "Priority const *""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  result = (bool)((Priority const *)arg1)->isSetMath();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Priority_setMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Priority *arg1 = (Priority *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Priority_setMath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Priority, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Priority_setMath" "', argument " "1"" of type '" "Priority *""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Priority_setMath" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (int)(arg1)->setMath((ASTNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Priority_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Priority *arg1 = (Priority *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Priority, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Priority_getTypeCode" "', argument " "1"" of type '" "Priority const *""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  result = (int)((Priority const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Priority_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Priority *arg1 = (Priority *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Priority, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Priority_getElementName" "', argument " "1"" of type '" "Priority const *""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  result = (std::string *) &((Priority const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Priority_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Priority *arg1 = (Priority *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Priority, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Priority_hasRequiredElements" "', argument " "1"" of type '" "Priority const *""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  result = (bool)((Priority const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Priority_removeFromParentAndDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Priority *arg1 = (Priority *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Priority, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Priority_removeFromParentAndDelete" "', argument " "1"" of type '" "Priority *""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  result = (int)(arg1)->removeFromParentAndDelete();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Priority_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Priority *arg1 = (Priority *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Priority_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Priority, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Priority_renameSIdRefs" "', argument " "1"" of type '" "Priority *""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Priority_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Priority_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Priority_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Priority_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Priority_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Priority *arg1 = (Priority *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Priority_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Priority, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Priority_renameUnitSIdRefs" "', argument " "1"" of type '" "Priority *""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Priority_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Priority_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Priority_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Priority_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Priority_replaceSIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Priority *arg1 = (Priority *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Priority_replaceSIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Priority, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Priority_replaceSIDWithFunction" "', argument " "1"" of type '" "Priority *""'"); 
  }
  arg1 = reinterpret_cast< Priority * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Priority_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Priority_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Priority_replaceSIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceSIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *Priority_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Priority, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Priority_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBO_isQuantitativeParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isQuantitativeParameter" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isQuantitativeParameter(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isParticipantRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isParticipantRole" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isParticipantRole(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isModellingFramework(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isModellingFramework" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isModellingFramework(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isMathematicalExpression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isMathematicalExpression" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isMathematicalExpression(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isKineticConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isKineticConstant" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isKineticConstant(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isReactant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isReactant" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isReactant(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isProduct" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isProduct(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isModifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isModifier" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isModifier(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isRateLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isRateLaw" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isRateLaw(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isEvent" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isEvent(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isPhysicalParticipant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isPhysicalParticipant" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isPhysicalParticipant(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isParticipant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isParticipant" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isParticipant(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isInteraction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isInteraction" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isInteraction(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isEntity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isEntity" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isEntity(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isFunctionalEntity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isFunctionalEntity" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isFunctionalEntity(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isMaterialEntity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isMaterialEntity" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isMaterialEntity(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isConservationLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isConservationLaw" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isConservationLaw(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isSteadyStateExpression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isSteadyStateExpression" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isSteadyStateExpression(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isFunctionalCompartment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isFunctionalCompartment" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isFunctionalCompartment(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isContinuousFramework(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isContinuousFramework" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isContinuousFramework(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isDiscreteFramework(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isDiscreteFramework" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isDiscreteFramework(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isLogicalFramework(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isLogicalFramework" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isLogicalFramework(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isMetadataRepresentation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isMetadataRepresentation" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isMetadataRepresentation(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isOccurringEntityRepresentation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isOccurringEntityRepresentation" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isOccurringEntityRepresentation(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isPhysicalEntityRepresentation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isPhysicalEntityRepresentation" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isPhysicalEntityRepresentation(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isSystemsDescriptionParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isSystemsDescriptionParameter" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isSystemsDescriptionParameter(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isQuantitativeSystemsDescriptionParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isQuantitativeSystemsDescriptionParameter" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isQuantitativeSystemsDescriptionParameter(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_isObselete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_isObselete" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (bool)SBO::isObselete(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_intToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_intToString" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = SBO::intToString(arg1);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_stringToInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBO_stringToInt" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBO_stringToInt" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (int)SBO::stringToInt((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_checkTerm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBO_checkTerm" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBO_checkTerm" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (bool)SBO::checkTerm((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_checkTerm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_checkTerm" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (bool)SBO::checkTerm(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBO_checkTerm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBO_checkTerm", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_SBO_checkTerm__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBO_checkTerm__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBO_checkTerm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBO::checkTerm(std::string const &)\n"
    "    SBO::checkTerm(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBO_getParentBranch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBO_getParentBranch" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (unsigned int)SBO::getParentBranch(arg1);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBO *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SBO", 0, 0, 0)) SWIG_fail;
  result = (SBO *)new SBO();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBO, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBO *arg1 = (SBO *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBO, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBO" "', argument " "1"" of type '" "SBO *""'"); 
  }
  arg1 = reinterpret_cast< SBO * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBO_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBO, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBO_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SyntaxChecker_isValidSBMLSId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SyntaxChecker_isValidSBMLSId" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)SyntaxChecker::isValidSBMLSId(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SyntaxChecker_isValidXMLID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SyntaxChecker_isValidXMLID" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)SyntaxChecker::isValidXMLID(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SyntaxChecker_isValidXMLanyURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SyntaxChecker_isValidXMLanyURI" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)SyntaxChecker::isValidXMLanyURI(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SyntaxChecker_isValidUnitSId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SyntaxChecker_isValidUnitSId" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)SyntaxChecker::isValidUnitSId(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SyntaxChecker_hasExpectedXHTMLSyntax__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SyntaxChecker_hasExpectedXHTMLSyntax" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SyntaxChecker_hasExpectedXHTMLSyntax" "', argument " "2"" of type '" "SBMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces * >(argp2);
  result = (bool)SyntaxChecker::hasExpectedXHTMLSyntax((XMLNode const *)arg1,arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SyntaxChecker_hasExpectedXHTMLSyntax__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SyntaxChecker_hasExpectedXHTMLSyntax" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  result = (bool)SyntaxChecker::hasExpectedXHTMLSyntax((XMLNode const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SyntaxChecker_hasExpectedXHTMLSyntax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SyntaxChecker_hasExpectedXHTMLSyntax", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SyntaxChecker_hasExpectedXHTMLSyntax__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SyntaxChecker_hasExpectedXHTMLSyntax__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SyntaxChecker_hasExpectedXHTMLSyntax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SyntaxChecker::hasExpectedXHTMLSyntax(XMLNode const *,SBMLNamespaces *)\n"
    "    SyntaxChecker::hasExpectedXHTMLSyntax(XMLNode const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SyntaxChecker_isValidInternalSId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SyntaxChecker_isValidInternalSId" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)SyntaxChecker::isValidInternalSId(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SyntaxChecker_isValidInternalUnitSId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SyntaxChecker_isValidInternalUnitSId" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)SyntaxChecker::isValidInternalUnitSId(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SyntaxChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SyntaxChecker *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SyntaxChecker", 0, 0, 0)) SWIG_fail;
  result = (SyntaxChecker *)new SyntaxChecker();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SyntaxChecker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SyntaxChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SyntaxChecker *arg1 = (SyntaxChecker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SyntaxChecker, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SyntaxChecker" "', argument " "1"" of type '" "SyntaxChecker *""'"); 
  }
  arg1 = reinterpret_cast< SyntaxChecker * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SyntaxChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SyntaxChecker, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SyntaxChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_StoichiometryMath__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  StoichiometryMath *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StoichiometryMath" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StoichiometryMath" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (StoichiometryMath *)new StoichiometryMath(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StoichiometryMath, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StoichiometryMath__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  StoichiometryMath *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StoichiometryMath" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (StoichiometryMath *)new StoichiometryMath(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StoichiometryMath, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StoichiometryMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StoichiometryMath" "', argument " "1"" of type '" "StoichiometryMath *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StoichiometryMath__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  StoichiometryMath *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_StoichiometryMath,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StoichiometryMath" "', argument " "1"" of type '" "StoichiometryMath const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StoichiometryMath" "', argument " "1"" of type '" "StoichiometryMath const &""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  {
    try {
      result = (StoichiometryMath *)new StoichiometryMath((StoichiometryMath const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StoichiometryMath, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StoichiometryMath(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_StoichiometryMath", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StoichiometryMath__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_StoichiometryMath, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StoichiometryMath__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_StoichiometryMath__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_StoichiometryMath'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    StoichiometryMath::StoichiometryMath(unsigned int,unsigned int)\n"
    "    StoichiometryMath::StoichiometryMath(SBMLNamespaces *)\n"
    "    StoichiometryMath::StoichiometryMath(StoichiometryMath const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  StoichiometryMath *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_clone" "', argument " "1"" of type '" "StoichiometryMath const *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  result = (StoichiometryMath *)((StoichiometryMath const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StoichiometryMath, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_getMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_getMath" "', argument " "1"" of type '" "StoichiometryMath const *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  result = (ASTNode *)((StoichiometryMath const *)arg1)->getMath();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_isSetMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_isSetMath" "', argument " "1"" of type '" "StoichiometryMath const *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  result = (bool)((StoichiometryMath const *)arg1)->isSetMath();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_setMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "StoichiometryMath_setMath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_setMath" "', argument " "1"" of type '" "StoichiometryMath *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StoichiometryMath_setMath" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (int)(arg1)->setMath((ASTNode const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_getDerivedUnitDefinition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_getDerivedUnitDefinition" "', argument " "1"" of type '" "StoichiometryMath *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  result = (UnitDefinition *)(arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_getDerivedUnitDefinition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UnitDefinition *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_getDerivedUnitDefinition" "', argument " "1"" of type '" "StoichiometryMath const *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  result = (UnitDefinition *)((StoichiometryMath const *)arg1)->getDerivedUnitDefinition();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_getDerivedUnitDefinition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StoichiometryMath_getDerivedUnitDefinition", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StoichiometryMath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StoichiometryMath_getDerivedUnitDefinition__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StoichiometryMath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StoichiometryMath_getDerivedUnitDefinition__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StoichiometryMath_getDerivedUnitDefinition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    StoichiometryMath::getDerivedUnitDefinition()\n"
    "    StoichiometryMath::getDerivedUnitDefinition() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_containsUndeclaredUnits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_containsUndeclaredUnits" "', argument " "1"" of type '" "StoichiometryMath *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  result = (bool)(arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_containsUndeclaredUnits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_containsUndeclaredUnits" "', argument " "1"" of type '" "StoichiometryMath const *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  result = (bool)((StoichiometryMath const *)arg1)->containsUndeclaredUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_containsUndeclaredUnits(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StoichiometryMath_containsUndeclaredUnits", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StoichiometryMath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StoichiometryMath_containsUndeclaredUnits__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StoichiometryMath, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StoichiometryMath_containsUndeclaredUnits__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StoichiometryMath_containsUndeclaredUnits'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    StoichiometryMath::containsUndeclaredUnits()\n"
    "    StoichiometryMath::containsUndeclaredUnits() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_getTypeCode" "', argument " "1"" of type '" "StoichiometryMath const *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  result = (int)((StoichiometryMath const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_getElementName" "', argument " "1"" of type '" "StoichiometryMath const *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  result = (std::string *) &((StoichiometryMath const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_hasRequiredElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_hasRequiredElements" "', argument " "1"" of type '" "StoichiometryMath const *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  result = (bool)((StoichiometryMath const *)arg1)->hasRequiredElements();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_removeFromParentAndDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_removeFromParentAndDelete" "', argument " "1"" of type '" "StoichiometryMath *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  result = (int)(arg1)->removeFromParentAndDelete();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StoichiometryMath_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_renameSIdRefs" "', argument " "1"" of type '" "StoichiometryMath *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StoichiometryMath_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StoichiometryMath_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StoichiometryMath_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StoichiometryMath_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StoichiometryMath_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_renameUnitSIdRefs" "', argument " "1"" of type '" "StoichiometryMath *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StoichiometryMath_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StoichiometryMath_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StoichiometryMath_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StoichiometryMath_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StoichiometryMath_replaceSIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  StoichiometryMath *arg1 = (StoichiometryMath *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StoichiometryMath_replaceSIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StoichiometryMath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StoichiometryMath_replaceSIDWithFunction" "', argument " "1"" of type '" "StoichiometryMath *""'"); 
  }
  arg1 = reinterpret_cast< StoichiometryMath * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StoichiometryMath_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StoichiometryMath_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StoichiometryMath_replaceSIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceSIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *StoichiometryMath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_StoichiometryMath, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StoichiometryMath_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBMLNamespaces__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SBMLNamespaces *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLNamespaces" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLNamespaces" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (SBMLNamespaces *)new SBMLNamespaces(arg1,arg2);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLNamespaces__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  SBMLNamespaces *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLNamespaces" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = (SBMLNamespaces *)new SBMLNamespaces(arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLNamespaces__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLNamespaces *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (SBMLNamespaces *)new SBMLNamespaces();
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLNamespaces__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  std::string *arg3 = 0 ;
  unsigned int arg4 ;
  std::string arg5 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  SBMLNamespaces *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLNamespaces" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLNamespaces" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SBMLNamespaces" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLNamespaces" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SBMLNamespaces" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SBMLNamespaces" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (SBMLNamespaces *)new SBMLNamespaces(arg1,arg2,(std::string const &)*arg3,arg4,arg5);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLNamespaces__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  std::string *arg3 = 0 ;
  unsigned int arg4 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  SBMLNamespaces *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLNamespaces" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLNamespaces" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SBMLNamespaces" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLNamespaces" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SBMLNamespaces" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = (SBMLNamespaces *)new SBMLNamespaces(arg1,arg2,(std::string const &)*arg3,arg4);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLNamespaces" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLNamespaces__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLNamespaces *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLNamespaces,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLNamespaces" "', argument " "1"" of type '" "SBMLNamespaces const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLNamespaces" "', argument " "1"" of type '" "SBMLNamespaces const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    try {
      result = (SBMLNamespaces *)new SBMLNamespaces((SBMLNamespaces const &)*arg1);
    }
    catch (SBMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
    catch (SBMLExtensionException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLNamespaces(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLNamespaces", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLNamespaces__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLNamespaces, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLNamespaces__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SBMLNamespaces__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBMLNamespaces__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SBMLNamespaces__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[4], (std::basic_string<char>**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SBMLNamespaces__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLNamespaces'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLNamespaces::SBMLNamespaces(unsigned int,unsigned int)\n"
    "    SBMLNamespaces::SBMLNamespaces(unsigned int)\n"
    "    SBMLNamespaces::SBMLNamespaces()\n"
    "    SBMLNamespaces::SBMLNamespaces(unsigned int,unsigned int,std::string const &,unsigned int,std::string const)\n"
    "    SBMLNamespaces::SBMLNamespaces(unsigned int,unsigned int,std::string const &,unsigned int)\n"
    "    SBMLNamespaces::SBMLNamespaces(SBMLNamespaces const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLNamespaces *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_clone" "', argument " "1"" of type '" "SBMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  result = (SBMLNamespaces *)((SBMLNamespaces const *)arg1)->clone();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getSBMLNamespaceURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespaces_getSBMLNamespaceURI", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBMLNamespaces_getSBMLNamespaceURI" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLNamespaces_getSBMLNamespaceURI" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = SBMLNamespaces::getSBMLNamespaceURI(arg1,arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getSupportedNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  List *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespaces_getSupportedNamespaces", 0, 0, 0)) SWIG_fail;
  result = (List *)SBMLNamespaces::getSupportedNamespaces();
  {
    ListWrapper<SBMLNamespaces> *listw = (result != 0) ? new ListWrapper<SBMLNamespaces>(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(listw),
      
      SWIGTYPE_p_ListWrapperT_SBMLNamespaces_t,
      
      
      
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_freeSBMLNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  List *arg1 = (List *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_List, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_freeSBMLNamespaces" "', argument " "1"" of type '" "List *""'"); 
  }
  arg1 = reinterpret_cast< List * >(argp1);
  SBMLNamespaces::freeSBMLNamespaces(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_getURI" "', argument " "1"" of type '" "SBMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  result = ((SBMLNamespaces const *)arg1)->getURI();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getLevel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_getLevel" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  result = (unsigned int)(arg1)->getLevel();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getLevel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_getLevel" "', argument " "1"" of type '" "SBMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  result = (unsigned int)((SBMLNamespaces const *)arg1)->getLevel();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getLevel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLNamespaces_getLevel", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLNamespaces_getLevel__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLNamespaces_getLevel__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLNamespaces_getLevel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLNamespaces::getLevel()\n"
    "    SBMLNamespaces::getLevel() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getVersion__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_getVersion" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  result = (unsigned int)(arg1)->getVersion();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getVersion__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_getVersion" "', argument " "1"" of type '" "SBMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  result = (unsigned int)((SBMLNamespaces const *)arg1)->getVersion();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getVersion(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLNamespaces_getVersion", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLNamespaces_getVersion__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLNamespaces_getVersion__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLNamespaces_getVersion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLNamespaces::getVersion()\n"
    "    SBMLNamespaces::getVersion() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getNamespaces__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLNamespaces *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_getNamespaces" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  result = (XMLNamespaces *)(arg1)->getNamespaces();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getNamespaces__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLNamespaces *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_getNamespaces" "', argument " "1"" of type '" "SBMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  result = (XMLNamespaces *)((SBMLNamespaces const *)arg1)->getNamespaces();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getNamespaces(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLNamespaces_getNamespaces", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLNamespaces_getNamespaces__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLNamespaces_getNamespaces__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLNamespaces_getNamespaces'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLNamespaces::getNamespaces()\n"
    "    SBMLNamespaces::getNamespaces() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_addNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  XMLNamespaces *arg2 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespaces_addNamespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_addNamespaces" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLNamespaces_addNamespaces" "', argument " "2"" of type '" "XMLNamespaces const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNamespaces * >(argp2);
  result = (int)(arg1)->addNamespaces((XMLNamespaces const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_addNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespaces_addNamespace", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_addNamespace" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLNamespaces_addNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLNamespaces_addNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBMLNamespaces_addNamespace" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLNamespaces_addNamespace" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (int)(arg1)->addNamespace((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_removeNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespaces_removeNamespace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_removeNamespace" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLNamespaces_removeNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLNamespaces_removeNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->removeNamespace((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_addPackageNamespace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_addPackageNamespace" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLNamespaces_addPackageNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLNamespaces_addPackageNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLNamespaces_addPackageNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res4 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBMLNamespaces_addPackageNamespace" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLNamespaces_addPackageNamespace" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  result = (int)(arg1)->addPackageNamespace((std::string const &)*arg2,arg3,(std::string const &)*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_addPackageNamespace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_addPackageNamespace" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLNamespaces_addPackageNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLNamespaces_addPackageNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLNamespaces_addPackageNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (int)(arg1)->addPackageNamespace((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_addPackageNamespace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLNamespaces_addPackageNamespace", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBMLNamespaces_addPackageNamespace__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBMLNamespaces_addPackageNamespace__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLNamespaces_addPackageNamespace'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLNamespaces::addPackageNamespace(std::string const &,unsigned int,std::string const &)\n"
    "    SBMLNamespaces::addPackageNamespace(std::string const &,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_addPackageNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  XMLNamespaces *arg2 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespaces_addPackageNamespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_addPackageNamespaces" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLNamespaces_addPackageNamespaces" "', argument " "2"" of type '" "XMLNamespaces const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNamespaces * >(argp2);
  result = (int)(arg1)->addPackageNamespaces((XMLNamespaces const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_removePackageNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string *arg4 = 0 ;
  unsigned int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespaces_removePackageNamespace", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_removePackageNamespace" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLNamespaces_removePackageNamespace" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLNamespaces_removePackageNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res4 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBMLNamespaces_removePackageNamespace" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLNamespaces_removePackageNamespace" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBMLNamespaces_removePackageNamespace" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  result = (int)(arg1)->removePackageNamespace(arg2,arg3,(std::string const &)*arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_addPkgNamespace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_addPkgNamespace" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLNamespaces_addPkgNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLNamespaces_addPkgNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLNamespaces_addPkgNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res4 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBMLNamespaces_addPkgNamespace" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLNamespaces_addPkgNamespace" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  result = (int)(arg1)->addPkgNamespace((std::string const &)*arg2,arg3,(std::string const &)*arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_addPkgNamespace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_addPkgNamespace" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLNamespaces_addPkgNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLNamespaces_addPkgNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLNamespaces_addPkgNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (int)(arg1)->addPkgNamespace((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_addPkgNamespace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLNamespaces_addPkgNamespace", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBMLNamespaces_addPkgNamespace__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SBMLNamespaces_addPkgNamespace__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLNamespaces_addPkgNamespace'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLNamespaces::addPkgNamespace(std::string const &,unsigned int,std::string const &)\n"
    "    SBMLNamespaces::addPkgNamespace(std::string const &,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_addPkgNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  XMLNamespaces *arg2 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespaces_addPkgNamespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_addPkgNamespaces" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLNamespaces_addPkgNamespaces" "', argument " "2"" of type '" "XMLNamespaces const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNamespaces * >(argp2);
  result = (int)(arg1)->addPkgNamespaces((XMLNamespaces const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_removePkgNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string *arg4 = 0 ;
  unsigned int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespaces_removePkgNamespace", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_removePkgNamespace" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLNamespaces_removePkgNamespace" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLNamespaces_removePkgNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res4 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBMLNamespaces_removePkgNamespace" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLNamespaces_removePkgNamespace" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBMLNamespaces_removePkgNamespace" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  result = (int)(arg1)->removePkgNamespace(arg2,arg3,(std::string const &)*arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_isSBMLNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_isSBMLNamespace" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLNamespaces_isSBMLNamespace" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (bool)SBMLNamespaces::isSBMLNamespace((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_isValidCombination(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_isValidCombination" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  result = (bool)(arg1)->isValidCombination();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_setLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespaces_setLevel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_setLevel" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLNamespaces_setLevel" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setLevel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_setVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespaces_setVersion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_setVersion" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLNamespaces_setVersion" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setVersion(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_setNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  XMLNamespaces *arg2 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLNamespaces_setNamespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_setNamespaces" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLNamespaces_setNamespaces" "', argument " "2"" of type '" "XMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< XMLNamespaces * >(argp2);
  (arg1)->setNamespaces(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLNamespaces_getPackageName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLNamespaces_getPackageName" "', argument " "1"" of type '" "SBMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  result = (std::string *) &((SBMLNamespaces const *)arg1)->getPackageName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLNamespaces_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLNamespaces, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLNamespaces_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLTransforms_replaceFD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  FunctionDefinition *arg2 = (FunctionDefinition *) 0 ;
  IdList *arg3 = (IdList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLTransforms_replaceFD" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLTransforms_replaceFD" "', argument " "2"" of type '" "FunctionDefinition const *""'"); 
  }
  arg2 = reinterpret_cast< FunctionDefinition * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_IdList, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBMLTransforms_replaceFD" "', argument " "3"" of type '" "IdList const *""'"); 
  }
  arg3 = reinterpret_cast< IdList * >(argp3);
  SBMLTransforms::replaceFD(arg1,(FunctionDefinition const *)arg2,(IdList const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLTransforms_replaceFD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  FunctionDefinition *arg2 = (FunctionDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLTransforms_replaceFD" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FunctionDefinition, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLTransforms_replaceFD" "', argument " "2"" of type '" "FunctionDefinition const *""'"); 
  }
  arg2 = reinterpret_cast< FunctionDefinition * >(argp2);
  SBMLTransforms::replaceFD(arg1,(FunctionDefinition const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLTransforms_replaceFD__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ListOfFunctionDefinitions *arg2 = (ListOfFunctionDefinitions *) 0 ;
  IdList *arg3 = (IdList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLTransforms_replaceFD" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLTransforms_replaceFD" "', argument " "2"" of type '" "ListOfFunctionDefinitions const *""'"); 
  }
  arg2 = reinterpret_cast< ListOfFunctionDefinitions * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_IdList, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBMLTransforms_replaceFD" "', argument " "3"" of type '" "IdList const *""'"); 
  }
  arg3 = reinterpret_cast< IdList * >(argp3);
  SBMLTransforms::replaceFD(arg1,(ListOfFunctionDefinitions const *)arg2,(IdList const *)arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLTransforms_replaceFD__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ListOfFunctionDefinitions *arg2 = (ListOfFunctionDefinitions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLTransforms_replaceFD" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ListOfFunctionDefinitions, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLTransforms_replaceFD" "', argument " "2"" of type '" "ListOfFunctionDefinitions const *""'"); 
  }
  arg2 = reinterpret_cast< ListOfFunctionDefinitions * >(argp2);
  SBMLTransforms::replaceFD(arg1,(ListOfFunctionDefinitions const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLTransforms_replaceFD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLTransforms_replaceFD", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FunctionDefinition, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBMLTransforms_replaceFD__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ListOfFunctionDefinitions, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBMLTransforms_replaceFD__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ListOfFunctionDefinitions, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_IdList, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBMLTransforms_replaceFD__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FunctionDefinition, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_IdList, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SBMLTransforms_replaceFD__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLTransforms_replaceFD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLTransforms::replaceFD(ASTNode *,FunctionDefinition const *,IdList const *)\n"
    "    SBMLTransforms::replaceFD(ASTNode *,FunctionDefinition const *)\n"
    "    SBMLTransforms::replaceFD(ASTNode *,ListOfFunctionDefinitions const *,IdList const *)\n"
    "    SBMLTransforms::replaceFD(ASTNode *,ListOfFunctionDefinitions const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLTransforms_expandInitialAssignments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLTransforms_expandInitialAssignments" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)SBMLTransforms::expandInitialAssignments(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLTransforms_evaluateASTNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  Model *arg2 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLTransforms_evaluateASTNode" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLTransforms_evaluateASTNode" "', argument " "2"" of type '" "Model const *""'"); 
  }
  arg2 = reinterpret_cast< Model * >(argp2);
  result = (double)SBMLTransforms::evaluateASTNode((ASTNode const *)arg1,(Model const *)arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLTransforms_evaluateASTNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLTransforms_evaluateASTNode" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (double)SBMLTransforms::evaluateASTNode((ASTNode const *)arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLTransforms_evaluateASTNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLTransforms_evaluateASTNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLTransforms_evaluateASTNode__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBMLTransforms_evaluateASTNode__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLTransforms_evaluateASTNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLTransforms::evaluateASTNode(ASTNode const *,Model const *)\n"
    "    SBMLTransforms::evaluateASTNode(ASTNode const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLTransforms_expandL3V2InitialAssignments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLTransforms_expandL3V2InitialAssignments" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = (bool)SBMLTransforms::expandL3V2InitialAssignments(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLTransforms_mapComponentValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  IdList result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLTransforms_mapComponentValues" "', argument " "1"" of type '" "Model const *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  result = SBMLTransforms::mapComponentValues((Model const *)arg1);
  resultobj = SWIG_NewPointerObj((new IdList(static_cast< const IdList& >(result))), SWIGTYPE_p_IdList, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLTransforms_clearComponentValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLTransforms_clearComponentValues", 0, 0, 0)) SWIG_fail;
  SBMLTransforms::clearComponentValues();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLTransforms_nodeContainsId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  IdList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLTransforms_nodeContainsId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLTransforms_nodeContainsId" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_IdList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLTransforms_nodeContainsId" "', argument " "2"" of type '" "IdList &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLTransforms_nodeContainsId" "', argument " "2"" of type '" "IdList &""'"); 
  }
  arg2 = reinterpret_cast< IdList * >(argp2);
  result = (bool)SBMLTransforms::nodeContainsId((ASTNode const *)arg1,*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLTransforms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLTransforms *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SBMLTransforms", 0, 0, 0)) SWIG_fail;
  result = (SBMLTransforms *)new SBMLTransforms();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLTransforms, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLTransforms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLTransforms *arg1 = (SBMLTransforms *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLTransforms, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLTransforms" "', argument " "1"" of type '" "SBMLTransforms *""'"); 
  }
  arg1 = reinterpret_cast< SBMLTransforms * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLTransforms_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLTransforms, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLTransforms_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  ConversionOptionType_t arg3 ;
  std::string arg4 ;
  int res1 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConversionOption" "', argument " "3"" of type '" "ConversionOptionType_t""'");
  } 
  arg3 = static_cast< ConversionOptionType_t >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ConversionOption" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  ConversionOptionType_t arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConversionOption" "', argument " "3"" of type '" "ConversionOptionType_t""'");
  } 
  arg3 = static_cast< ConversionOptionType_t >(val3);
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  int res1 = SWIG_OLDOBJ ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  std::string arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ConversionOption" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,(char const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  std::string arg3 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ConversionOption" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  double arg2 ;
  std::string arg3 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ConversionOption" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  double arg2 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  float arg2 ;
  std::string arg3 ;
  int res1 = SWIG_OLDOBJ ;
  float val2 ;
  int ecode2 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ConversionOption" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  float arg2 ;
  int res1 = SWIG_OLDOBJ ;
  float val2 ;
  int ecode2 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_12(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int arg2 ;
  std::string arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int val2 ;
  int ecode2 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ConversionOption" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_13(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int arg2 ;
  int res1 = SWIG_OLDOBJ ;
  int val2 ;
  int ecode2 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConversionOption" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ConversionOption *)new ConversionOption((std::string const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption__SWIG_14(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ConversionOption,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionOption" "', argument " "1"" of type '" "ConversionOption const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionOption" "', argument " "1"" of type '" "ConversionOption const &""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  result = (ConversionOption *)new ConversionOption((ConversionOption const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionOption(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConversionOption", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ConversionOption, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConversionOption__SWIG_14(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConversionOption__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ConversionOption__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ConversionOption__SWIG_13(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ConversionOption__SWIG_11(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ConversionOption__SWIG_9(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ConversionOption__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ConversionOption__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ConversionOption__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ConversionOption__SWIG_12(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ConversionOption__SWIG_10(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ConversionOption__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ConversionOption__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ConversionOption__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ConversionOption__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConversionOption'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConversionOption::ConversionOption(std::string const &,std::string const,ConversionOptionType_t,std::string const)\n"
    "    ConversionOption::ConversionOption(std::string const &,std::string const,ConversionOptionType_t)\n"
    "    ConversionOption::ConversionOption(std::string const &,std::string const)\n"
    "    ConversionOption::ConversionOption(std::string const &)\n"
    "    ConversionOption::ConversionOption(std::string const &,char const *,std::string const)\n"
    "    ConversionOption::ConversionOption(std::string const &,char const *)\n"
    "    ConversionOption::ConversionOption(std::string const &,bool,std::string const)\n"
    "    ConversionOption::ConversionOption(std::string const &,bool)\n"
    "    ConversionOption::ConversionOption(std::string const &,double,std::string const)\n"
    "    ConversionOption::ConversionOption(std::string const &,double)\n"
    "    ConversionOption::ConversionOption(std::string const &,float,std::string const)\n"
    "    ConversionOption::ConversionOption(std::string const &,float)\n"
    "    ConversionOption::ConversionOption(std::string const &,int,std::string const)\n"
    "    ConversionOption::ConversionOption(std::string const &,int)\n"
    "    ConversionOption::ConversionOption(ConversionOption const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConversionOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConversionOption" "', argument " "1"" of type '" "ConversionOption *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionOption *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_clone" "', argument " "1"" of type '" "ConversionOption const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  result = (ConversionOption *)((ConversionOption const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_getKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_getKey" "', argument " "1"" of type '" "ConversionOption const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  result = (std::string *) &((ConversionOption const *)arg1)->getKey();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_setKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionOption_setKey", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_setKey" "', argument " "1"" of type '" "ConversionOption *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionOption_setKey" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionOption_setKey" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->setKey((std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_getValue" "', argument " "1"" of type '" "ConversionOption const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  result = (std::string *) &((ConversionOption const *)arg1)->getValue();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionOption_setValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_setValue" "', argument " "1"" of type '" "ConversionOption *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionOption_setValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionOption_setValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->setValue((std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_getDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_getDescription" "', argument " "1"" of type '" "ConversionOption const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  result = (std::string *) &((ConversionOption const *)arg1)->getDescription();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_setDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionOption_setDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_setDescription" "', argument " "1"" of type '" "ConversionOption *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionOption_setDescription" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionOption_setDescription" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->setDescription((std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionOptionType_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_getType" "', argument " "1"" of type '" "ConversionOption const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  result = (ConversionOptionType_t)((ConversionOption const *)arg1)->getType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_setType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  ConversionOptionType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionOption_setType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_setType" "', argument " "1"" of type '" "ConversionOption *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConversionOption_setType" "', argument " "2"" of type '" "ConversionOptionType_t""'");
  } 
  arg2 = static_cast< ConversionOptionType_t >(val2);
  (arg1)->setType(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_getBoolValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_getBoolValue" "', argument " "1"" of type '" "ConversionOption const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  result = (bool)((ConversionOption const *)arg1)->getBoolValue();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_setBoolValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionOption_setBoolValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_setBoolValue" "', argument " "1"" of type '" "ConversionOption *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConversionOption_setBoolValue" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setBoolValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_getDoubleValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_getDoubleValue" "', argument " "1"" of type '" "ConversionOption const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  result = (double)((ConversionOption const *)arg1)->getDoubleValue();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_setDoubleValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionOption_setDoubleValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_setDoubleValue" "', argument " "1"" of type '" "ConversionOption *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConversionOption_setDoubleValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setDoubleValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_getFloatValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_getFloatValue" "', argument " "1"" of type '" "ConversionOption const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  result = (float)((ConversionOption const *)arg1)->getFloatValue();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_setFloatValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionOption_setFloatValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_setFloatValue" "', argument " "1"" of type '" "ConversionOption *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConversionOption_setFloatValue" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setFloatValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_getIntValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_getIntValue" "', argument " "1"" of type '" "ConversionOption const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  result = (int)((ConversionOption const *)arg1)->getIntValue();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionOption_setIntValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionOption *arg1 = (ConversionOption *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionOption_setIntValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionOption_setIntValue" "', argument " "1"" of type '" "ConversionOption *""'"); 
  }
  arg1 = reinterpret_cast< ConversionOption * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConversionOption_setIntValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setIntValue(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConversionOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ConversionOption, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConversionOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ConversionProperties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLNamespaces *arg1 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ConversionProperties *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionProperties" "', argument " "1"" of type '" "SBMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< SBMLNamespaces * >(argp1);
  result = (ConversionProperties *)new ConversionProperties(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionProperties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ConversionProperties *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ConversionProperties *)new ConversionProperties();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionProperties__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ConversionProperties *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConversionProperties" "', argument " "1"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConversionProperties" "', argument " "1"" of type '" "ConversionProperties const &""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  result = (ConversionProperties *)new ConversionProperties((ConversionProperties const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConversionProperties(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConversionProperties", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ConversionProperties__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConversionProperties__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ConversionProperties, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConversionProperties__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConversionProperties'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConversionProperties::ConversionProperties(SBMLNamespaces *)\n"
    "    ConversionProperties::ConversionProperties()\n"
    "    ConversionProperties::ConversionProperties(ConversionProperties const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionProperties *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_clone" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  result = (ConversionProperties *)((ConversionProperties const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ConversionProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConversionProperties" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_getTargetNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLNamespaces *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_getTargetNamespaces" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  result = (SBMLNamespaces *)((ConversionProperties const *)arg1)->getTargetNamespaces();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_hasTargetNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_hasTargetNamespaces" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  result = (bool)((ConversionProperties const *)arg1)->hasTargetNamespaces();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_setTargetNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_setTargetNamespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_setTargetNamespaces" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_setTargetNamespaces" "', argument " "2"" of type '" "SBMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces * >(argp2);
  (arg1)->setTargetNamespaces(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_getDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::string *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_getDescription", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_getDescription" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_getDescription" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_getDescription" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (std::string *) &((ConversionProperties const *)arg1)->getDescription((std::string const &)*arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  ConversionOptionType_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_getType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_getType" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_getType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_getType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ConversionOptionType_t)((ConversionProperties const *)arg1)->getType((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_getOption__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_getOption" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_getOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_getOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ConversionOption *)((ConversionProperties const *)arg1)->getOption((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_getOption__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ConversionOption *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_getOption" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConversionProperties_getOption" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (ConversionOption *)((ConversionProperties const *)arg1)->getOption(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_getOption(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ConversionProperties_getOption", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ConversionProperties_getOption__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConversionProperties_getOption__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConversionProperties_getOption'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConversionProperties::getOption(std::string const &) const\n"
    "    ConversionProperties::getOption(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  ConversionOption *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionOption,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "ConversionOption const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "ConversionOption const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionOption * >(argp2);
  (arg1)->addOption((ConversionOption const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  ConversionOptionType_t arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConversionProperties_addOption" "', argument " "4"" of type '" "ConversionOptionType_t""'");
  } 
  arg4 = static_cast< ConversionOptionType_t >(val4);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ConversionProperties_addOption" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addOption((std::string const &)*arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  ConversionOptionType_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConversionProperties_addOption" "', argument " "4"" of type '" "ConversionOptionType_t""'");
  } 
  arg4 = static_cast< ConversionOptionType_t >(val4);
  (arg1)->addOption((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addOption((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->addOption((std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ConversionProperties_addOption" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addOption((std::string const &)*arg2,(char const *)arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  (arg1)->addOption((std::string const &)*arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ConversionProperties_addOption" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addOption((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->addOption((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ConversionProperties_addOption" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addOption((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->addOption((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  float arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ConversionProperties_addOption" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addOption((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_12(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->addOption((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_13(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ConversionProperties_addOption" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addOption((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption__SWIG_14(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_addOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_addOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConversionProperties_addOption" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->addOption((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_addOption(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ConversionProperties_addOption", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ConversionOption, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConversionProperties_addOption__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConversionProperties_addOption__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ConversionProperties_addOption__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ConversionProperties_addOption__SWIG_14(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ConversionProperties_addOption__SWIG_12(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ConversionProperties_addOption__SWIG_10(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ConversionProperties_addOption__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ConversionProperties_addOption__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ConversionProperties_addOption__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ConversionProperties_addOption__SWIG_13(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ConversionProperties_addOption__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ConversionProperties_addOption__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ConversionProperties_addOption__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ConversionProperties_addOption__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ConversionProperties, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[4], (std::basic_string<char>**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ConversionProperties_addOption__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConversionProperties_addOption'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConversionProperties::addOption(ConversionOption const &)\n"
    "    ConversionProperties::addOption(std::string const &,std::string const,ConversionOptionType_t,std::string const)\n"
    "    ConversionProperties::addOption(std::string const &,std::string const,ConversionOptionType_t)\n"
    "    ConversionProperties::addOption(std::string const &,std::string const)\n"
    "    ConversionProperties::addOption(std::string const &)\n"
    "    ConversionProperties::addOption(std::string const &,char const *,std::string const)\n"
    "    ConversionProperties::addOption(std::string const &,char const *)\n"
    "    ConversionProperties::addOption(std::string const &,bool,std::string const)\n"
    "    ConversionProperties::addOption(std::string const &,bool)\n"
    "    ConversionProperties::addOption(std::string const &,double,std::string const)\n"
    "    ConversionProperties::addOption(std::string const &,double)\n"
    "    ConversionProperties::addOption(std::string const &,float,std::string const)\n"
    "    ConversionProperties::addOption(std::string const &,float)\n"
    "    ConversionProperties::addOption(std::string const &,int,std::string const)\n"
    "    ConversionProperties::addOption(std::string const &,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_removeOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  ConversionOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_removeOption", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_removeOption" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_removeOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_removeOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ConversionOption *)(arg1)->removeOption((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionOption, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_hasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_hasOption", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_hasOption" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_hasOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_hasOption" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((ConversionProperties const *)arg1)->hasOption((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::string *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_getValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_getValue" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_getValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_getValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (std::string *) &((ConversionProperties const *)arg1)->getValue((std::string const &)*arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_setValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_setValue" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_setValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_setValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConversionProperties_setValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_setValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->setValue((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_getBoolValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_getBoolValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_getBoolValue" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_getBoolValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_getBoolValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((ConversionProperties const *)arg1)->getBoolValue((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_setBoolValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_setBoolValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_setBoolValue" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_setBoolValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_setBoolValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConversionProperties_setBoolValue" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setBoolValue((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_getDoubleValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_getDoubleValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_getDoubleValue" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_getDoubleValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_getDoubleValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (double)((ConversionProperties const *)arg1)->getDoubleValue((std::string const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_setDoubleValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_setDoubleValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_setDoubleValue" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_setDoubleValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_setDoubleValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConversionProperties_setDoubleValue" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setDoubleValue((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_getFloatValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  float result;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_getFloatValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_getFloatValue" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_getFloatValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_getFloatValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (float)((ConversionProperties const *)arg1)->getFloatValue((std::string const &)*arg2);
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_setFloatValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_setFloatValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_setFloatValue" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_setFloatValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_setFloatValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConversionProperties_setFloatValue" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setFloatValue((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_getIntValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_getIntValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_getIntValue" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_getIntValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_getIntValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)((ConversionProperties const *)arg1)->getIntValue((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_setIntValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ConversionProperties_setIntValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_setIntValue" "', argument " "1"" of type '" "ConversionProperties *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConversionProperties_setIntValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConversionProperties_setIntValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConversionProperties_setIntValue" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setIntValue((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConversionProperties_getNumOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConversionProperties *arg1 = (ConversionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConversionProperties_getNumOptions" "', argument " "1"" of type '" "ConversionProperties const *""'"); 
  }
  arg1 = reinterpret_cast< ConversionProperties * >(argp1);
  result = (int)((ConversionProperties const *)arg1)->getNumOptions();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConversionProperties_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ConversionProperties, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConversionProperties_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBMLConverter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  SBMLConverter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = swig_obj[0];
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (SBMLConverter *)new SwigDirector_SBMLConverter(arg1); 
  } else {
    result = (SBMLConverter *)new SBMLConverter(); 
  }
  
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLConverter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  std::string *arg2 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SBMLConverter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBMLConverter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLConverter" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (SBMLConverter *)new SwigDirector_SBMLConverter(arg1,(std::string const &)*arg2); 
  } else {
    result = (SBMLConverter *)new SBMLConverter((std::string const &)*arg2); 
  }
  
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLConverter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  SBMLConverter *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SBMLConverter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SBMLConverter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBMLConverter" "', argument " "2"" of type '" "SBMLConverter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLConverter" "', argument " "2"" of type '" "SBMLConverter const &""'"); 
  }
  arg2 = reinterpret_cast< SBMLConverter * >(argp2);
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (SBMLConverter *)new SwigDirector_SBMLConverter(arg1,(SBMLConverter const &)*arg2); 
  } else {
    result = (SBMLConverter *)new SBMLConverter((SBMLConverter const &)*arg2); 
  }
  
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_NEW |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLConverter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLConverter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      return _wrap_new_SBMLConverter__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SBMLConverter, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SBMLConverter__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SBMLConverter__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLConverter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLConverter::SBMLConverter()\n"
    "    SBMLConverter::SBMLConverter(std::string const &)\n"
    "    SBMLConverter::SBMLConverter(PyObject *,SBMLConverter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMLConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLConverter" "', argument " "1"" of type '" "SBMLConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SBMLConverter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverter_clone" "', argument " "1"" of type '" "SBMLConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (SBMLConverter *)((SBMLConverter const *)arg1)->SBMLConverter::clone();
    } else {
      result = (SBMLConverter *)((SBMLConverter const *)arg1)->clone();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    Py_INCREF(resultobj);
  } else {
    {
      resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
        SWIG_POINTER_OWN |  0 );
    }
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverter_getDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverter_getDocument" "', argument " "1"" of type '" "SBMLConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (SBMLDocument *)(arg1)->SBMLConverter::getDocument();
    } else {
      result = (SBMLDocument *)(arg1)->getDocument();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverter_getDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverter_getDocument" "', argument " "1"" of type '" "SBMLConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (SBMLDocument *)((SBMLConverter const *)arg1)->SBMLConverter::getDocument();
    } else {
      result = (SBMLDocument *)((SBMLConverter const *)arg1)->getDocument();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverter_getDocument(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLConverter_getDocument", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLConverter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLConverter_getDocument__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLConverter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLConverter_getDocument__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLConverter_getDocument'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLConverter::getDocument()\n"
    "    SBMLConverter::getDocument() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLConverter_getDefaultProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  ConversionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverter_getDefaultProperties" "', argument " "1"" of type '" "SBMLConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = ((SBMLConverter const *)arg1)->SBMLConverter::getDefaultProperties();
    } else {
      result = ((SBMLConverter const *)arg1)->getDefaultProperties();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj((new ConversionProperties(static_cast< const ConversionProperties& >(result))), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverter_getTargetNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SBMLNamespaces *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverter_getTargetNamespaces" "', argument " "1"" of type '" "SBMLConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (SBMLNamespaces *)(arg1)->SBMLConverter::getTargetNamespaces();
    } else {
      result = (SBMLNamespaces *)(arg1)->getTargetNamespaces();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverter_matchesProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLConverter_matchesProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverter_matchesProperties" "', argument " "1"" of type '" "SBMLConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (bool)((SBMLConverter const *)arg1)->SBMLConverter::matchesProperties((ConversionProperties const &)*arg2);
    } else {
      result = (bool)((SBMLConverter const *)arg1)->matchesProperties((ConversionProperties const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverter_setDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLConverter_setDocument", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverter_setDocument" "', argument " "1"" of type '" "SBMLConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLConverter_setDocument" "', argument " "2"" of type '" "SBMLDocument *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (int)(arg1)->SBMLConverter::setDocument(arg2);
    } else {
      result = (int)(arg1)->setDocument(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverter_setProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  ConversionProperties *arg2 = (ConversionProperties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLConverter_setProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverter_setProperties" "', argument " "1"" of type '" "SBMLConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLConverter_setProperties" "', argument " "2"" of type '" "ConversionProperties const *""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (int)(arg1)->SBMLConverter::setProperties((ConversionProperties const *)arg2);
    } else {
      result = (int)(arg1)->setProperties((ConversionProperties const *)arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverter_getProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  ConversionProperties *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverter_getProperties" "', argument " "1"" of type '" "SBMLConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (ConversionProperties *)((SBMLConverter const *)arg1)->SBMLConverter::getProperties();
    } else {
      result = (ConversionProperties *)((SBMLConverter const *)arg1)->getProperties();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConversionProperties, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverter_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverter_convert" "', argument " "1"" of type '" "SBMLConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (int)(arg1)->SBMLConverter::convert();
    } else {
      result = (int)(arg1)->convert();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverter_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverter_getName" "', argument " "1"" of type '" "SBMLConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  result = (std::string *) &((SBMLConverter const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_SBMLConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverter *arg1 = (SBMLConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_SBMLConverter" "', argument " "1"" of type '" "SBMLConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverter * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLConverter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLConverterRegistry_getInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverterRegistry *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLConverterRegistry_getInstance", 0, 0, 0)) SWIG_fail;
  result = (SBMLConverterRegistry *) &SBMLConverterRegistry::getInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLConverterRegistry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverterRegistry_addConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverterRegistry *arg1 = (SBMLConverterRegistry *) 0 ;
  SBMLConverter *arg2 = (SBMLConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLConverterRegistry_addConverter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverterRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverterRegistry_addConverter" "', argument " "1"" of type '" "SBMLConverterRegistry *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverterRegistry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLConverter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLConverterRegistry_addConverter" "', argument " "2"" of type '" "SBMLConverter const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLConverter * >(argp2);
  result = (int)(arg1)->addConverter((SBMLConverter const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverterRegistry_getConverterByIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverterRegistry *arg1 = (SBMLConverterRegistry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  SBMLConverter *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLConverterRegistry_getConverterByIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverterRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverterRegistry_getConverterByIndex" "', argument " "1"" of type '" "SBMLConverterRegistry const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverterRegistry * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLConverterRegistry_getConverterByIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SBMLConverter *)((SBMLConverterRegistry const *)arg1)->getConverterByIndex(arg2);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    Py_INCREF(resultobj);
  } else {
    {
      resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
        0 |  0 );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverterRegistry_getConverterFor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverterRegistry *arg1 = (SBMLConverterRegistry *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  SBMLConverter *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLConverterRegistry_getConverterFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverterRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverterRegistry_getConverterFor" "', argument " "1"" of type '" "SBMLConverterRegistry const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverterRegistry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLConverterRegistry_getConverterFor" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLConverterRegistry_getConverterFor" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (SBMLConverter *)((SBMLConverterRegistry const *)arg1)->getConverterFor((ConversionProperties const &)*arg2);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    Py_INCREF(resultobj);
  } else {
    {
      resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
        0 |  0 );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLConverterRegistry_getNumConverters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverterRegistry *arg1 = (SBMLConverterRegistry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverterRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLConverterRegistry_getNumConverters" "', argument " "1"" of type '" "SBMLConverterRegistry const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverterRegistry * >(argp1);
  result = (int)((SBMLConverterRegistry const *)arg1)->getNumConverters();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLConverterRegistry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLConverterRegistry *arg1 = (SBMLConverterRegistry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLConverterRegistry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLConverterRegistry" "', argument " "1"" of type '" "SBMLConverterRegistry *""'"); 
  }
  arg1 = reinterpret_cast< SBMLConverterRegistry * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLConverterRegistry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLConverterRegistry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SBMLFunctionDefinitionConverter_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLFunctionDefinitionConverter_init", 0, 0, 0)) SWIG_fail;
  SBMLFunctionDefinitionConverter::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLFunctionDefinitionConverter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLFunctionDefinitionConverter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLFunctionDefinitionConverter *)new SBMLFunctionDefinitionConverter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLFunctionDefinitionConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLFunctionDefinitionConverter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLFunctionDefinitionConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLFunctionDefinitionConverter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLFunctionDefinitionConverter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLFunctionDefinitionConverter" "', argument " "1"" of type '" "SBMLFunctionDefinitionConverter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLFunctionDefinitionConverter" "', argument " "1"" of type '" "SBMLFunctionDefinitionConverter const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLFunctionDefinitionConverter * >(argp1);
  result = (SBMLFunctionDefinitionConverter *)new SBMLFunctionDefinitionConverter((SBMLFunctionDefinitionConverter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLFunctionDefinitionConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLFunctionDefinitionConverter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLFunctionDefinitionConverter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLFunctionDefinitionConverter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLFunctionDefinitionConverter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLFunctionDefinitionConverter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLFunctionDefinitionConverter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLFunctionDefinitionConverter::SBMLFunctionDefinitionConverter()\n"
    "    SBMLFunctionDefinitionConverter::SBMLFunctionDefinitionConverter(SBMLFunctionDefinitionConverter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLFunctionDefinitionConverter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLFunctionDefinitionConverter *arg1 = (SBMLFunctionDefinitionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLFunctionDefinitionConverter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLFunctionDefinitionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLFunctionDefinitionConverter_clone" "', argument " "1"" of type '" "SBMLFunctionDefinitionConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLFunctionDefinitionConverter * >(argp1);
  result = (SBMLFunctionDefinitionConverter *)((SBMLFunctionDefinitionConverter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLFunctionDefinitionConverter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLFunctionDefinitionConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLFunctionDefinitionConverter *arg1 = (SBMLFunctionDefinitionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLFunctionDefinitionConverter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLFunctionDefinitionConverter" "', argument " "1"" of type '" "SBMLFunctionDefinitionConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLFunctionDefinitionConverter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLFunctionDefinitionConverter_matchesProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLFunctionDefinitionConverter *arg1 = (SBMLFunctionDefinitionConverter *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLFunctionDefinitionConverter_matchesProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLFunctionDefinitionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLFunctionDefinitionConverter_matchesProperties" "', argument " "1"" of type '" "SBMLFunctionDefinitionConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLFunctionDefinitionConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLFunctionDefinitionConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLFunctionDefinitionConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (bool)((SBMLFunctionDefinitionConverter const *)arg1)->matchesProperties((ConversionProperties const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLFunctionDefinitionConverter_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLFunctionDefinitionConverter *arg1 = (SBMLFunctionDefinitionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLFunctionDefinitionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLFunctionDefinitionConverter_convert" "', argument " "1"" of type '" "SBMLFunctionDefinitionConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLFunctionDefinitionConverter * >(argp1);
  result = (int)(arg1)->convert();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLFunctionDefinitionConverter_getDefaultProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLFunctionDefinitionConverter *arg1 = (SBMLFunctionDefinitionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLFunctionDefinitionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLFunctionDefinitionConverter_getDefaultProperties" "', argument " "1"" of type '" "SBMLFunctionDefinitionConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLFunctionDefinitionConverter * >(argp1);
  result = ((SBMLFunctionDefinitionConverter const *)arg1)->getDefaultProperties();
  resultobj = SWIG_NewPointerObj((new ConversionProperties(static_cast< const ConversionProperties& >(result))), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLFunctionDefinitionConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLFunctionDefinitionConverter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLFunctionDefinitionConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLIdConverter_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLIdConverter_init", 0, 0, 0)) SWIG_fail;
  SBMLIdConverter::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLIdConverter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLIdConverter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLIdConverter *)new SBMLIdConverter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLIdConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLIdConverter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLIdConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLIdConverter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLIdConverter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLIdConverter" "', argument " "1"" of type '" "SBMLIdConverter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLIdConverter" "', argument " "1"" of type '" "SBMLIdConverter const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLIdConverter * >(argp1);
  result = (SBMLIdConverter *)new SBMLIdConverter((SBMLIdConverter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLIdConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLIdConverter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLIdConverter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLIdConverter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLIdConverter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLIdConverter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLIdConverter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLIdConverter::SBMLIdConverter()\n"
    "    SBMLIdConverter::SBMLIdConverter(SBMLIdConverter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLIdConverter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLIdConverter *arg1 = (SBMLIdConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLIdConverter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLIdConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLIdConverter_clone" "', argument " "1"" of type '" "SBMLIdConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLIdConverter * >(argp1);
  result = (SBMLIdConverter *)((SBMLIdConverter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLIdConverter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLIdConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLIdConverter *arg1 = (SBMLIdConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLIdConverter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLIdConverter" "', argument " "1"" of type '" "SBMLIdConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLIdConverter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLIdConverter_matchesProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLIdConverter *arg1 = (SBMLIdConverter *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLIdConverter_matchesProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLIdConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLIdConverter_matchesProperties" "', argument " "1"" of type '" "SBMLIdConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLIdConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLIdConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLIdConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (bool)((SBMLIdConverter const *)arg1)->matchesProperties((ConversionProperties const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLIdConverter_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLIdConverter *arg1 = (SBMLIdConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLIdConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLIdConverter_convert" "', argument " "1"" of type '" "SBMLIdConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLIdConverter * >(argp1);
  result = (int)(arg1)->convert();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLIdConverter_getDefaultProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLIdConverter *arg1 = (SBMLIdConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLIdConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLIdConverter_getDefaultProperties" "', argument " "1"" of type '" "SBMLIdConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLIdConverter * >(argp1);
  result = ((SBMLIdConverter const *)arg1)->getDefaultProperties();
  resultobj = SWIG_NewPointerObj((new ConversionProperties(static_cast< const ConversionProperties& >(result))), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLIdConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLIdConverter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLIdConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLInferUnitsConverter_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLInferUnitsConverter_init", 0, 0, 0)) SWIG_fail;
  SBMLInferUnitsConverter::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLInferUnitsConverter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLInferUnitsConverter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLInferUnitsConverter *)new SBMLInferUnitsConverter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLInferUnitsConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLInferUnitsConverter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLInferUnitsConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLInferUnitsConverter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLInferUnitsConverter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLInferUnitsConverter" "', argument " "1"" of type '" "SBMLInferUnitsConverter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLInferUnitsConverter" "', argument " "1"" of type '" "SBMLInferUnitsConverter const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLInferUnitsConverter * >(argp1);
  result = (SBMLInferUnitsConverter *)new SBMLInferUnitsConverter((SBMLInferUnitsConverter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLInferUnitsConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLInferUnitsConverter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLInferUnitsConverter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLInferUnitsConverter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLInferUnitsConverter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLInferUnitsConverter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLInferUnitsConverter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLInferUnitsConverter::SBMLInferUnitsConverter()\n"
    "    SBMLInferUnitsConverter::SBMLInferUnitsConverter(SBMLInferUnitsConverter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMLInferUnitsConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLInferUnitsConverter *arg1 = (SBMLInferUnitsConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLInferUnitsConverter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLInferUnitsConverter" "', argument " "1"" of type '" "SBMLInferUnitsConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLInferUnitsConverter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLInferUnitsConverter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLInferUnitsConverter *arg1 = (SBMLInferUnitsConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLInferUnitsConverter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLInferUnitsConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLInferUnitsConverter_clone" "', argument " "1"" of type '" "SBMLInferUnitsConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLInferUnitsConverter * >(argp1);
  result = (SBMLInferUnitsConverter *)((SBMLInferUnitsConverter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLInferUnitsConverter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLInferUnitsConverter_matchesProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLInferUnitsConverter *arg1 = (SBMLInferUnitsConverter *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLInferUnitsConverter_matchesProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLInferUnitsConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLInferUnitsConverter_matchesProperties" "', argument " "1"" of type '" "SBMLInferUnitsConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLInferUnitsConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLInferUnitsConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLInferUnitsConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (bool)((SBMLInferUnitsConverter const *)arg1)->matchesProperties((ConversionProperties const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLInferUnitsConverter_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLInferUnitsConverter *arg1 = (SBMLInferUnitsConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLInferUnitsConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLInferUnitsConverter_convert" "', argument " "1"" of type '" "SBMLInferUnitsConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLInferUnitsConverter * >(argp1);
  result = (int)(arg1)->convert();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLInferUnitsConverter_getDefaultProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLInferUnitsConverter *arg1 = (SBMLInferUnitsConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLInferUnitsConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLInferUnitsConverter_getDefaultProperties" "', argument " "1"" of type '" "SBMLInferUnitsConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLInferUnitsConverter * >(argp1);
  result = ((SBMLInferUnitsConverter const *)arg1)->getDefaultProperties();
  resultobj = SWIG_NewPointerObj((new ConversionProperties(static_cast< const ConversionProperties& >(result))), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLInferUnitsConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLInferUnitsConverter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLInferUnitsConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLInitialAssignmentConverter_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLInitialAssignmentConverter_init", 0, 0, 0)) SWIG_fail;
  SBMLInitialAssignmentConverter::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLInitialAssignmentConverter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLInitialAssignmentConverter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLInitialAssignmentConverter *)new SBMLInitialAssignmentConverter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLInitialAssignmentConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLInitialAssignmentConverter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLInitialAssignmentConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLInitialAssignmentConverter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLInitialAssignmentConverter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLInitialAssignmentConverter" "', argument " "1"" of type '" "SBMLInitialAssignmentConverter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLInitialAssignmentConverter" "', argument " "1"" of type '" "SBMLInitialAssignmentConverter const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLInitialAssignmentConverter * >(argp1);
  result = (SBMLInitialAssignmentConverter *)new SBMLInitialAssignmentConverter((SBMLInitialAssignmentConverter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLInitialAssignmentConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLInitialAssignmentConverter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLInitialAssignmentConverter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLInitialAssignmentConverter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLInitialAssignmentConverter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLInitialAssignmentConverter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLInitialAssignmentConverter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLInitialAssignmentConverter::SBMLInitialAssignmentConverter()\n"
    "    SBMLInitialAssignmentConverter::SBMLInitialAssignmentConverter(SBMLInitialAssignmentConverter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLInitialAssignmentConverter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLInitialAssignmentConverter *arg1 = (SBMLInitialAssignmentConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLInitialAssignmentConverter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLInitialAssignmentConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLInitialAssignmentConverter_clone" "', argument " "1"" of type '" "SBMLInitialAssignmentConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLInitialAssignmentConverter * >(argp1);
  result = (SBMLInitialAssignmentConverter *)((SBMLInitialAssignmentConverter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLInitialAssignmentConverter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLInitialAssignmentConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLInitialAssignmentConverter *arg1 = (SBMLInitialAssignmentConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLInitialAssignmentConverter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLInitialAssignmentConverter" "', argument " "1"" of type '" "SBMLInitialAssignmentConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLInitialAssignmentConverter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLInitialAssignmentConverter_matchesProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLInitialAssignmentConverter *arg1 = (SBMLInitialAssignmentConverter *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLInitialAssignmentConverter_matchesProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLInitialAssignmentConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLInitialAssignmentConverter_matchesProperties" "', argument " "1"" of type '" "SBMLInitialAssignmentConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLInitialAssignmentConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLInitialAssignmentConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLInitialAssignmentConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (bool)((SBMLInitialAssignmentConverter const *)arg1)->matchesProperties((ConversionProperties const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLInitialAssignmentConverter_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLInitialAssignmentConverter *arg1 = (SBMLInitialAssignmentConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLInitialAssignmentConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLInitialAssignmentConverter_convert" "', argument " "1"" of type '" "SBMLInitialAssignmentConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLInitialAssignmentConverter * >(argp1);
  result = (int)(arg1)->convert();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLInitialAssignmentConverter_getDefaultProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLInitialAssignmentConverter *arg1 = (SBMLInitialAssignmentConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLInitialAssignmentConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLInitialAssignmentConverter_getDefaultProperties" "', argument " "1"" of type '" "SBMLInitialAssignmentConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLInitialAssignmentConverter * >(argp1);
  result = ((SBMLInitialAssignmentConverter const *)arg1)->getDefaultProperties();
  resultobj = SWIG_NewPointerObj((new ConversionProperties(static_cast< const ConversionProperties& >(result))), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLInitialAssignmentConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLInitialAssignmentConverter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLInitialAssignmentConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLLevelVersionConverter_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLLevelVersionConverter_init", 0, 0, 0)) SWIG_fail;
  SBMLLevelVersionConverter::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLLevelVersionConverter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLLevelVersionConverter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLLevelVersionConverter *)new SBMLLevelVersionConverter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLLevelVersionConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLLevelVersionConverter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLLevelVersionConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLLevelVersionConverter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLLevelVersionConverter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLLevelVersionConverter" "', argument " "1"" of type '" "SBMLLevelVersionConverter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLLevelVersionConverter" "', argument " "1"" of type '" "SBMLLevelVersionConverter const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevelVersionConverter * >(argp1);
  result = (SBMLLevelVersionConverter *)new SBMLLevelVersionConverter((SBMLLevelVersionConverter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLLevelVersionConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLLevelVersionConverter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLLevelVersionConverter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLLevelVersionConverter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLLevelVersionConverter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLLevelVersionConverter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLLevelVersionConverter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLLevelVersionConverter::SBMLLevelVersionConverter()\n"
    "    SBMLLevelVersionConverter::SBMLLevelVersionConverter(SBMLLevelVersionConverter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMLLevelVersionConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevelVersionConverter *arg1 = (SBMLLevelVersionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevelVersionConverter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLLevelVersionConverter" "', argument " "1"" of type '" "SBMLLevelVersionConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevelVersionConverter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLevelVersionConverter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevelVersionConverter *arg1 = (SBMLLevelVersionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLLevelVersionConverter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevelVersionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLevelVersionConverter_clone" "', argument " "1"" of type '" "SBMLLevelVersionConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevelVersionConverter * >(argp1);
  result = (SBMLLevelVersionConverter *)((SBMLLevelVersionConverter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLLevelVersionConverter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLevelVersionConverter_matchesProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevelVersionConverter *arg1 = (SBMLLevelVersionConverter *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLLevelVersionConverter_matchesProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevelVersionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLevelVersionConverter_matchesProperties" "', argument " "1"" of type '" "SBMLLevelVersionConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevelVersionConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLLevelVersionConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLLevelVersionConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (bool)((SBMLLevelVersionConverter const *)arg1)->matchesProperties((ConversionProperties const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLevelVersionConverter_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevelVersionConverter *arg1 = (SBMLLevelVersionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevelVersionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLevelVersionConverter_convert" "', argument " "1"" of type '" "SBMLLevelVersionConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevelVersionConverter * >(argp1);
  result = (int)(arg1)->convert();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLevelVersionConverter_getDefaultProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevelVersionConverter *arg1 = (SBMLLevelVersionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevelVersionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLevelVersionConverter_getDefaultProperties" "', argument " "1"" of type '" "SBMLLevelVersionConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevelVersionConverter * >(argp1);
  result = ((SBMLLevelVersionConverter const *)arg1)->getDefaultProperties();
  resultobj = SWIG_NewPointerObj((new ConversionProperties(static_cast< const ConversionProperties& >(result))), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLevelVersionConverter_getTargetLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevelVersionConverter *arg1 = (SBMLLevelVersionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevelVersionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLevelVersionConverter_getTargetLevel" "', argument " "1"" of type '" "SBMLLevelVersionConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevelVersionConverter * >(argp1);
  result = (unsigned int)(arg1)->getTargetLevel();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLevelVersionConverter_getTargetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevelVersionConverter *arg1 = (SBMLLevelVersionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevelVersionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLevelVersionConverter_getTargetVersion" "', argument " "1"" of type '" "SBMLLevelVersionConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevelVersionConverter * >(argp1);
  result = (unsigned int)(arg1)->getTargetVersion();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLevelVersionConverter_getValidityFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevelVersionConverter *arg1 = (SBMLLevelVersionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevelVersionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLevelVersionConverter_getValidityFlag" "', argument " "1"" of type '" "SBMLLevelVersionConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevelVersionConverter * >(argp1);
  result = (bool)(arg1)->getValidityFlag();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLevelVersionConverter_getAddDefaultUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevelVersionConverter *arg1 = (SBMLLevelVersionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevelVersionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLevelVersionConverter_getAddDefaultUnits" "', argument " "1"" of type '" "SBMLLevelVersionConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevelVersionConverter * >(argp1);
  result = (bool)(arg1)->getAddDefaultUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLLevelVersionConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLLevelVersionConverter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLLevelVersionConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLLevel1Version1Converter_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLLevel1Version1Converter_init", 0, 0, 0)) SWIG_fail;
  SBMLLevel1Version1Converter::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLLevel1Version1Converter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLLevel1Version1Converter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLLevel1Version1Converter *)new SBMLLevel1Version1Converter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLLevel1Version1Converter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLLevel1Version1Converter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLLevel1Version1Converter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLLevel1Version1Converter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLLevel1Version1Converter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLLevel1Version1Converter" "', argument " "1"" of type '" "SBMLLevel1Version1Converter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLLevel1Version1Converter" "', argument " "1"" of type '" "SBMLLevel1Version1Converter const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevel1Version1Converter * >(argp1);
  result = (SBMLLevel1Version1Converter *)new SBMLLevel1Version1Converter((SBMLLevel1Version1Converter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLLevel1Version1Converter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLLevel1Version1Converter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLLevel1Version1Converter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLLevel1Version1Converter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLLevel1Version1Converter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLLevel1Version1Converter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLLevel1Version1Converter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLLevel1Version1Converter::SBMLLevel1Version1Converter()\n"
    "    SBMLLevel1Version1Converter::SBMLLevel1Version1Converter(SBMLLevel1Version1Converter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMLLevel1Version1Converter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevel1Version1Converter *arg1 = (SBMLLevel1Version1Converter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevel1Version1Converter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLLevel1Version1Converter" "', argument " "1"" of type '" "SBMLLevel1Version1Converter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevel1Version1Converter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLevel1Version1Converter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevel1Version1Converter *arg1 = (SBMLLevel1Version1Converter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLLevel1Version1Converter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevel1Version1Converter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLevel1Version1Converter_clone" "', argument " "1"" of type '" "SBMLLevel1Version1Converter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevel1Version1Converter * >(argp1);
  result = (SBMLLevel1Version1Converter *)((SBMLLevel1Version1Converter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLLevel1Version1Converter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLevel1Version1Converter_matchesProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevel1Version1Converter *arg1 = (SBMLLevel1Version1Converter *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLLevel1Version1Converter_matchesProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevel1Version1Converter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLevel1Version1Converter_matchesProperties" "', argument " "1"" of type '" "SBMLLevel1Version1Converter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevel1Version1Converter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLLevel1Version1Converter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLLevel1Version1Converter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (bool)((SBMLLevel1Version1Converter const *)arg1)->matchesProperties((ConversionProperties const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLevel1Version1Converter_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevel1Version1Converter *arg1 = (SBMLLevel1Version1Converter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevel1Version1Converter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLevel1Version1Converter_convert" "', argument " "1"" of type '" "SBMLLevel1Version1Converter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevel1Version1Converter * >(argp1);
  result = (int)(arg1)->convert();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLevel1Version1Converter_getDefaultProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLevel1Version1Converter *arg1 = (SBMLLevel1Version1Converter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLevel1Version1Converter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLevel1Version1Converter_getDefaultProperties" "', argument " "1"" of type '" "SBMLLevel1Version1Converter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLevel1Version1Converter * >(argp1);
  result = ((SBMLLevel1Version1Converter const *)arg1)->getDefaultProperties();
  resultobj = SWIG_NewPointerObj((new ConversionProperties(static_cast< const ConversionProperties& >(result))), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLLevel1Version1Converter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLLevel1Version1Converter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLLevel1Version1Converter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLLocalParameterConverter_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLLocalParameterConverter_init", 0, 0, 0)) SWIG_fail;
  SBMLLocalParameterConverter::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLLocalParameterConverter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLLocalParameterConverter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLLocalParameterConverter *)new SBMLLocalParameterConverter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLLocalParameterConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLLocalParameterConverter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLLocalParameterConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLLocalParameterConverter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLLocalParameterConverter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLLocalParameterConverter" "', argument " "1"" of type '" "SBMLLocalParameterConverter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLLocalParameterConverter" "', argument " "1"" of type '" "SBMLLocalParameterConverter const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLLocalParameterConverter * >(argp1);
  result = (SBMLLocalParameterConverter *)new SBMLLocalParameterConverter((SBMLLocalParameterConverter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLLocalParameterConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLLocalParameterConverter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLLocalParameterConverter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLLocalParameterConverter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLLocalParameterConverter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLLocalParameterConverter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLLocalParameterConverter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLLocalParameterConverter::SBMLLocalParameterConverter()\n"
    "    SBMLLocalParameterConverter::SBMLLocalParameterConverter(SBMLLocalParameterConverter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLLocalParameterConverter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLocalParameterConverter *arg1 = (SBMLLocalParameterConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLLocalParameterConverter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLocalParameterConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLocalParameterConverter_clone" "', argument " "1"" of type '" "SBMLLocalParameterConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLocalParameterConverter * >(argp1);
  result = (SBMLLocalParameterConverter *)((SBMLLocalParameterConverter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLLocalParameterConverter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLLocalParameterConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLocalParameterConverter *arg1 = (SBMLLocalParameterConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLocalParameterConverter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLLocalParameterConverter" "', argument " "1"" of type '" "SBMLLocalParameterConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLocalParameterConverter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLocalParameterConverter_matchesProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLocalParameterConverter *arg1 = (SBMLLocalParameterConverter *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLLocalParameterConverter_matchesProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLocalParameterConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLocalParameterConverter_matchesProperties" "', argument " "1"" of type '" "SBMLLocalParameterConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLocalParameterConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLLocalParameterConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLLocalParameterConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (bool)((SBMLLocalParameterConverter const *)arg1)->matchesProperties((ConversionProperties const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLocalParameterConverter_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLocalParameterConverter *arg1 = (SBMLLocalParameterConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLocalParameterConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLocalParameterConverter_convert" "', argument " "1"" of type '" "SBMLLocalParameterConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLocalParameterConverter * >(argp1);
  result = (int)(arg1)->convert();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLLocalParameterConverter_getDefaultProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLLocalParameterConverter *arg1 = (SBMLLocalParameterConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLLocalParameterConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLLocalParameterConverter_getDefaultProperties" "', argument " "1"" of type '" "SBMLLocalParameterConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLLocalParameterConverter * >(argp1);
  result = ((SBMLLocalParameterConverter const *)arg1)->getDefaultProperties();
  resultobj = SWIG_NewPointerObj((new ConversionProperties(static_cast< const ConversionProperties& >(result))), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLLocalParameterConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLLocalParameterConverter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLLocalParameterConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLReactionConverter_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLReactionConverter_init", 0, 0, 0)) SWIG_fail;
  SBMLReactionConverter::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLReactionConverter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLReactionConverter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLReactionConverter *)new SBMLReactionConverter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLReactionConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLReactionConverter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLReactionConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLReactionConverter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLReactionConverter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLReactionConverter" "', argument " "1"" of type '" "SBMLReactionConverter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLReactionConverter" "', argument " "1"" of type '" "SBMLReactionConverter const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLReactionConverter * >(argp1);
  result = (SBMLReactionConverter *)new SBMLReactionConverter((SBMLReactionConverter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLReactionConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLReactionConverter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLReactionConverter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLReactionConverter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLReactionConverter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLReactionConverter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLReactionConverter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLReactionConverter::SBMLReactionConverter()\n"
    "    SBMLReactionConverter::SBMLReactionConverter(SBMLReactionConverter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLReactionConverter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLReactionConverter *arg1 = (SBMLReactionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLReactionConverter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLReactionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLReactionConverter_clone" "', argument " "1"" of type '" "SBMLReactionConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLReactionConverter * >(argp1);
  result = (SBMLReactionConverter *)((SBMLReactionConverter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLReactionConverter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLReactionConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLReactionConverter *arg1 = (SBMLReactionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLReactionConverter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLReactionConverter" "', argument " "1"" of type '" "SBMLReactionConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLReactionConverter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLReactionConverter_matchesProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLReactionConverter *arg1 = (SBMLReactionConverter *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLReactionConverter_matchesProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLReactionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLReactionConverter_matchesProperties" "', argument " "1"" of type '" "SBMLReactionConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLReactionConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLReactionConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLReactionConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (bool)((SBMLReactionConverter const *)arg1)->matchesProperties((ConversionProperties const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLReactionConverter_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLReactionConverter *arg1 = (SBMLReactionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLReactionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLReactionConverter_convert" "', argument " "1"" of type '" "SBMLReactionConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLReactionConverter * >(argp1);
  result = (int)(arg1)->convert();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLReactionConverter_getDefaultProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLReactionConverter *arg1 = (SBMLReactionConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLReactionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLReactionConverter_getDefaultProperties" "', argument " "1"" of type '" "SBMLReactionConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLReactionConverter * >(argp1);
  result = ((SBMLReactionConverter const *)arg1)->getDefaultProperties();
  resultobj = SWIG_NewPointerObj((new ConversionProperties(static_cast< const ConversionProperties& >(result))), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLReactionConverter_setDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLReactionConverter *arg1 = (SBMLReactionConverter *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLReactionConverter_setDocument", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLReactionConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLReactionConverter_setDocument" "', argument " "1"" of type '" "SBMLReactionConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLReactionConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLReactionConverter_setDocument" "', argument " "2"" of type '" "SBMLDocument *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  result = (int)(arg1)->setDocument(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLReactionConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLReactionConverter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLReactionConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLRuleConverter_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLRuleConverter_init", 0, 0, 0)) SWIG_fail;
  SBMLRuleConverter::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLRuleConverter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLRuleConverter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLRuleConverter *)new SBMLRuleConverter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLRuleConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLRuleConverter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLRuleConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLRuleConverter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLRuleConverter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLRuleConverter" "', argument " "1"" of type '" "SBMLRuleConverter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLRuleConverter" "', argument " "1"" of type '" "SBMLRuleConverter const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLRuleConverter * >(argp1);
  result = (SBMLRuleConverter *)new SBMLRuleConverter((SBMLRuleConverter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLRuleConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLRuleConverter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLRuleConverter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLRuleConverter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLRuleConverter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLRuleConverter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLRuleConverter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLRuleConverter::SBMLRuleConverter()\n"
    "    SBMLRuleConverter::SBMLRuleConverter(SBMLRuleConverter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLRuleConverter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLRuleConverter *arg1 = (SBMLRuleConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLRuleConverter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLRuleConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLRuleConverter_clone" "', argument " "1"" of type '" "SBMLRuleConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLRuleConverter * >(argp1);
  result = (SBMLRuleConverter *)((SBMLRuleConverter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLRuleConverter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLRuleConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLRuleConverter *arg1 = (SBMLRuleConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLRuleConverter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLRuleConverter" "', argument " "1"" of type '" "SBMLRuleConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLRuleConverter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLRuleConverter_matchesProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLRuleConverter *arg1 = (SBMLRuleConverter *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLRuleConverter_matchesProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLRuleConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLRuleConverter_matchesProperties" "', argument " "1"" of type '" "SBMLRuleConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLRuleConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLRuleConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLRuleConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (bool)((SBMLRuleConverter const *)arg1)->matchesProperties((ConversionProperties const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLRuleConverter_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLRuleConverter *arg1 = (SBMLRuleConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLRuleConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLRuleConverter_convert" "', argument " "1"" of type '" "SBMLRuleConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLRuleConverter * >(argp1);
  result = (int)(arg1)->convert();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLRuleConverter_getDefaultProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLRuleConverter *arg1 = (SBMLRuleConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLRuleConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLRuleConverter_getDefaultProperties" "', argument " "1"" of type '" "SBMLRuleConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLRuleConverter * >(argp1);
  result = ((SBMLRuleConverter const *)arg1)->getDefaultProperties();
  resultobj = SWIG_NewPointerObj((new ConversionProperties(static_cast< const ConversionProperties& >(result))), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLRuleConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLRuleConverter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLRuleConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLStripPackageConverter_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLStripPackageConverter_init", 0, 0, 0)) SWIG_fail;
  SBMLStripPackageConverter::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLStripPackageConverter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLStripPackageConverter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLStripPackageConverter *)new SBMLStripPackageConverter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLStripPackageConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLStripPackageConverter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLStripPackageConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLStripPackageConverter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLStripPackageConverter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLStripPackageConverter" "', argument " "1"" of type '" "SBMLStripPackageConverter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLStripPackageConverter" "', argument " "1"" of type '" "SBMLStripPackageConverter const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLStripPackageConverter * >(argp1);
  result = (SBMLStripPackageConverter *)new SBMLStripPackageConverter((SBMLStripPackageConverter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLStripPackageConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLStripPackageConverter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLStripPackageConverter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLStripPackageConverter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLStripPackageConverter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLStripPackageConverter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLStripPackageConverter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLStripPackageConverter::SBMLStripPackageConverter()\n"
    "    SBMLStripPackageConverter::SBMLStripPackageConverter(SBMLStripPackageConverter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMLStripPackageConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLStripPackageConverter *arg1 = (SBMLStripPackageConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLStripPackageConverter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLStripPackageConverter" "', argument " "1"" of type '" "SBMLStripPackageConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLStripPackageConverter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLStripPackageConverter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLStripPackageConverter *arg1 = (SBMLStripPackageConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLStripPackageConverter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLStripPackageConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLStripPackageConverter_clone" "', argument " "1"" of type '" "SBMLStripPackageConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLStripPackageConverter * >(argp1);
  result = (SBMLStripPackageConverter *)((SBMLStripPackageConverter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLStripPackageConverter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLStripPackageConverter_matchesProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLStripPackageConverter *arg1 = (SBMLStripPackageConverter *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLStripPackageConverter_matchesProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLStripPackageConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLStripPackageConverter_matchesProperties" "', argument " "1"" of type '" "SBMLStripPackageConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLStripPackageConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLStripPackageConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLStripPackageConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (bool)((SBMLStripPackageConverter const *)arg1)->matchesProperties((ConversionProperties const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLStripPackageConverter_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLStripPackageConverter *arg1 = (SBMLStripPackageConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLStripPackageConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLStripPackageConverter_convert" "', argument " "1"" of type '" "SBMLStripPackageConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLStripPackageConverter * >(argp1);
  result = (int)(arg1)->convert();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLStripPackageConverter_getDefaultProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLStripPackageConverter *arg1 = (SBMLStripPackageConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLStripPackageConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLStripPackageConverter_getDefaultProperties" "', argument " "1"" of type '" "SBMLStripPackageConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLStripPackageConverter * >(argp1);
  result = ((SBMLStripPackageConverter const *)arg1)->getDefaultProperties();
  resultobj = SWIG_NewPointerObj((new ConversionProperties(static_cast< const ConversionProperties& >(result))), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLStripPackageConverter_getPackageToStrip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLStripPackageConverter *arg1 = (SBMLStripPackageConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLStripPackageConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLStripPackageConverter_getPackageToStrip" "', argument " "1"" of type '" "SBMLStripPackageConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLStripPackageConverter * >(argp1);
  result = ((SBMLStripPackageConverter const *)arg1)->getPackageToStrip();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLStripPackageConverter_isStripAllUnrecognizedPackages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLStripPackageConverter *arg1 = (SBMLStripPackageConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLStripPackageConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLStripPackageConverter_isStripAllUnrecognizedPackages" "', argument " "1"" of type '" "SBMLStripPackageConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLStripPackageConverter * >(argp1);
  result = (bool)((SBMLStripPackageConverter const *)arg1)->isStripAllUnrecognizedPackages();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLStripPackageConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLStripPackageConverter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLStripPackageConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLUnitsConverter_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLUnitsConverter_init", 0, 0, 0)) SWIG_fail;
  SBMLUnitsConverter::init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLUnitsConverter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLUnitsConverter *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLUnitsConverter *)new SBMLUnitsConverter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLUnitsConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLUnitsConverter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLUnitsConverter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLUnitsConverter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLUnitsConverter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLUnitsConverter" "', argument " "1"" of type '" "SBMLUnitsConverter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLUnitsConverter" "', argument " "1"" of type '" "SBMLUnitsConverter const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLUnitsConverter * >(argp1);
  result = (SBMLUnitsConverter *)new SBMLUnitsConverter((SBMLUnitsConverter const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLUnitsConverter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLUnitsConverter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLUnitsConverter", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLUnitsConverter__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLUnitsConverter, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLUnitsConverter__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLUnitsConverter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLUnitsConverter::SBMLUnitsConverter()\n"
    "    SBMLUnitsConverter::SBMLUnitsConverter(SBMLUnitsConverter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMLUnitsConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLUnitsConverter *arg1 = (SBMLUnitsConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLUnitsConverter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLUnitsConverter" "', argument " "1"" of type '" "SBMLUnitsConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLUnitsConverter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLUnitsConverter_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLUnitsConverter *arg1 = (SBMLUnitsConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLUnitsConverter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLUnitsConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLUnitsConverter_clone" "', argument " "1"" of type '" "SBMLUnitsConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLUnitsConverter * >(argp1);
  result = (SBMLUnitsConverter *)((SBMLUnitsConverter const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLUnitsConverter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLUnitsConverter_matchesProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLUnitsConverter *arg1 = (SBMLUnitsConverter *) 0 ;
  ConversionProperties *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLUnitsConverter_matchesProperties", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLUnitsConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLUnitsConverter_matchesProperties" "', argument " "1"" of type '" "SBMLUnitsConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLUnitsConverter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ConversionProperties,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLUnitsConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLUnitsConverter_matchesProperties" "', argument " "2"" of type '" "ConversionProperties const &""'"); 
  }
  arg2 = reinterpret_cast< ConversionProperties * >(argp2);
  result = (bool)((SBMLUnitsConverter const *)arg1)->matchesProperties((ConversionProperties const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLUnitsConverter_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLUnitsConverter *arg1 = (SBMLUnitsConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLUnitsConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLUnitsConverter_convert" "', argument " "1"" of type '" "SBMLUnitsConverter *""'"); 
  }
  arg1 = reinterpret_cast< SBMLUnitsConverter * >(argp1);
  result = (int)(arg1)->convert();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLUnitsConverter_getDefaultProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLUnitsConverter *arg1 = (SBMLUnitsConverter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ConversionProperties result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLUnitsConverter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLUnitsConverter_getDefaultProperties" "', argument " "1"" of type '" "SBMLUnitsConverter const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLUnitsConverter * >(argp1);
  result = ((SBMLUnitsConverter const *)arg1)->getDefaultProperties();
  resultobj = SWIG_NewPointerObj((new ConversionProperties(static_cast< const ConversionProperties& >(result))), SWIGTYPE_p_ConversionProperties, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLUnitsConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLUnitsConverter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLUnitsConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBMLValidator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  SBMLValidator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = swig_obj[0];
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (SBMLValidator *)new SwigDirector_SBMLValidator(arg1); 
  } else {
    result = (SBMLValidator *)new SBMLValidator(); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLValidator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLValidator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  SBMLValidator *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SBMLValidator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SBMLValidator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBMLValidator" "', argument " "2"" of type '" "SBMLValidator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLValidator" "', argument " "2"" of type '" "SBMLValidator const &""'"); 
  }
  arg2 = reinterpret_cast< SBMLValidator * >(argp2);
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (SBMLValidator *)new SwigDirector_SBMLValidator(arg1,(SBMLValidator const &)*arg2); 
  } else {
    result = (SBMLValidator *)new SBMLValidator((SBMLValidator const &)*arg2); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLValidator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLValidator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLValidator", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      return _wrap_new_SBMLValidator__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SBMLValidator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SBMLValidator__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLValidator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLValidator::SBMLValidator()\n"
    "    SBMLValidator::SBMLValidator(PyObject *,SBMLValidator const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMLValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLValidator" "', argument " "1"" of type '" "SBMLValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  SBMLValidator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_clone" "', argument " "1"" of type '" "SBMLValidator const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (SBMLValidator *)((SBMLValidator const *)arg1)->SBMLValidator::clone();
    } else {
      result = (SBMLValidator *)((SBMLValidator const *)arg1)->clone();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLValidator, SWIG_POINTER_OWN |  0 );
  }
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_getDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_getDocument" "', argument " "1"" of type '" "SBMLValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (SBMLDocument *)(arg1)->SBMLValidator::getDocument();
    } else {
      result = (SBMLDocument *)(arg1)->getDocument();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_getDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_getDocument" "', argument " "1"" of type '" "SBMLValidator const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (SBMLDocument *)((SBMLValidator const *)arg1)->SBMLValidator::getDocument();
    } else {
      result = (SBMLDocument *)((SBMLValidator const *)arg1)->getDocument();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (director) {
    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_getDocument(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLValidator_getDocument", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLValidator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLValidator_getDocument__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLValidator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLValidator_getDocument__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLValidator_getDocument'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLValidator::getDocument()\n"
    "    SBMLValidator::getDocument() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_setDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLValidator_setDocument", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_setDocument" "', argument " "1"" of type '" "SBMLValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLValidator_setDocument" "', argument " "2"" of type '" "SBMLDocument const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (int)(arg1)->SBMLValidator::setDocument((SBMLDocument const *)arg2);
    } else {
      result = (int)(arg1)->setDocument((SBMLDocument const *)arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_validate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_validate" "', argument " "1"" of type '" "SBMLValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (unsigned int)(arg1)->SBMLValidator::validate();
    } else {
      result = (unsigned int)(arg1)->validate();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_clearFailures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_clearFailures" "', argument " "1"" of type '" "SBMLValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      (arg1)->SBMLValidator::clearFailures();
    } else {
      (arg1)->clearFailures();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_logFailure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  SBMLError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLValidator_logFailure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_logFailure" "', argument " "1"" of type '" "SBMLValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SBMLError,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLValidator_logFailure" "', argument " "2"" of type '" "SBMLError const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLValidator_logFailure" "', argument " "2"" of type '" "SBMLError const &""'"); 
  }
  arg2 = reinterpret_cast< SBMLError * >(argp2);
  (arg1)->logFailure((SBMLError const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_validate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  SBMLDocument *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_validate" "', argument " "1"" of type '" "SBMLValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SBMLDocument,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLValidator_validate" "', argument " "2"" of type '" "SBMLDocument const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLValidator_validate" "', argument " "2"" of type '" "SBMLDocument const &""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  result = (unsigned int)(arg1)->validate((SBMLDocument const &)*arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_validate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_validate" "', argument " "1"" of type '" "SBMLValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLValidator_validate" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLValidator_validate" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (unsigned int)(arg1)->validate((std::string const &)*arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_validate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLValidator_validate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLValidator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLValidator_validate__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLValidator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SBMLDocument, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBMLValidator_validate__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLValidator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBMLValidator_validate__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLValidator_validate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLValidator::validate()\n"
    "    SBMLValidator::validate(SBMLDocument const &)\n"
    "    SBMLValidator::validate(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_getErrorLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLErrorLog *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_getErrorLog" "', argument " "1"" of type '" "SBMLValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  result = (SBMLErrorLog *)(arg1)->getErrorLog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_getModel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Model *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_getModel" "', argument " "1"" of type '" "SBMLValidator const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  result = (Model *)((SBMLValidator const *)arg1)->getModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Model, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_getModel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Model *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_getModel" "', argument " "1"" of type '" "SBMLValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  result = (Model *)(arg1)->getModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Model, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_getModel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLValidator_getModel", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLValidator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLValidator_getModel__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLValidator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLValidator_getModel__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLValidator_getModel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLValidator::getModel() const\n"
    "    SBMLValidator::getModel()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_getNumFailures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_getNumFailures" "', argument " "1"" of type '" "SBMLValidator const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  result = (unsigned int)((SBMLValidator const *)arg1)->getNumFailures();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLValidator_getFailure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBMLError *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLValidator_getFailure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLValidator_getFailure" "', argument " "1"" of type '" "SBMLValidator const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLValidator_getFailure" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBMLError *)((SBMLValidator const *)arg1)->getFailure(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_SBMLValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLValidator *arg1 = (SBMLValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_SBMLValidator" "', argument " "1"" of type '" "SBMLValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLValidator * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLValidator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBMLExternalValidator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLExternalValidator *)new SBMLExternalValidator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLExternalValidator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLExternalValidator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLExternalValidator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLExternalValidator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLExternalValidator" "', argument " "1"" of type '" "SBMLExternalValidator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLExternalValidator" "', argument " "1"" of type '" "SBMLExternalValidator const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  result = (SBMLExternalValidator *)new SBMLExternalValidator((SBMLExternalValidator const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLExternalValidator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLExternalValidator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLExternalValidator", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLExternalValidator__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLExternalValidator, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLExternalValidator__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLExternalValidator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLExternalValidator::SBMLExternalValidator()\n"
    "    SBMLExternalValidator::SBMLExternalValidator(SBMLExternalValidator const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLExternalValidator_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  SBMLValidator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExternalValidator_clone" "', argument " "1"" of type '" "SBMLExternalValidator const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  result = (SBMLValidator *)((SBMLExternalValidator const *)arg1)->clone();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLValidator, SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLExternalValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLExternalValidator" "', argument " "1"" of type '" "SBMLExternalValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExternalValidator_validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExternalValidator_validate" "', argument " "1"" of type '" "SBMLExternalValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  result = (unsigned int)(arg1)->validate();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExternalValidator_getProgram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExternalValidator_getProgram" "', argument " "1"" of type '" "SBMLExternalValidator const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  result = (std::string *) &((SBMLExternalValidator const *)arg1)->getProgram();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExternalValidator_setProgram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExternalValidator_setProgram", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExternalValidator_setProgram" "', argument " "1"" of type '" "SBMLExternalValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLExternalValidator_setProgram" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setProgram(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExternalValidator_getOutputFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExternalValidator_getOutputFileName" "', argument " "1"" of type '" "SBMLExternalValidator const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  result = (std::string *) &((SBMLExternalValidator const *)arg1)->getOutputFileName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExternalValidator_setOutputFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExternalValidator_setOutputFileName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExternalValidator_setOutputFileName" "', argument " "1"" of type '" "SBMLExternalValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLExternalValidator_setOutputFileName" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setOutputFileName(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExternalValidator_getSBMLFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExternalValidator_getSBMLFileName" "', argument " "1"" of type '" "SBMLExternalValidator const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  result = (std::string *) &((SBMLExternalValidator const *)arg1)->getSBMLFileName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExternalValidator_setSBMLFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExternalValidator_setSBMLFileName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExternalValidator_setSBMLFileName" "', argument " "1"" of type '" "SBMLExternalValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLExternalValidator_setSBMLFileName" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setSBMLFileName(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExternalValidator_clearArguments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExternalValidator_clearArguments" "', argument " "1"" of type '" "SBMLExternalValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  (arg1)->clearArguments();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExternalValidator_addArgument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExternalValidator_addArgument", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExternalValidator_addArgument" "', argument " "1"" of type '" "SBMLExternalValidator *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLExternalValidator_addArgument" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addArgument(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExternalValidator_getNumArguments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExternalValidator_getNumArguments" "', argument " "1"" of type '" "SBMLExternalValidator const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  result = (unsigned int)((SBMLExternalValidator const *)arg1)->getNumArguments();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExternalValidator_getArgument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExternalValidator *arg1 = (SBMLExternalValidator *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExternalValidator_getArgument", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExternalValidator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExternalValidator_getArgument" "', argument " "1"" of type '" "SBMLExternalValidator const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExternalValidator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLExternalValidator_getArgument" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = ((SBMLExternalValidator const *)arg1)->getArgument(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLExternalValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLExternalValidator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLExternalValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_XMLAttributes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  XMLAttributes *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (XMLAttributes *)new XMLAttributes();
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_XMLAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLAttributes" "', argument " "1"" of type '" "XMLAttributes *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLAttributes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLAttributes *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLAttributes" "', argument " "1"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLAttributes" "', argument " "1"" of type '" "XMLAttributes const &""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  {
    try {
      result = (XMLAttributes *)new XMLAttributes((XMLAttributes const &)*arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLAttributes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_XMLAttributes", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_XMLAttributes__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLAttributes__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_XMLAttributes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLAttributes::XMLAttributes()\n"
    "    XMLAttributes::XMLAttributes(XMLAttributes const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLAttributes *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_clone" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  result = (XMLAttributes *)((XMLAttributes const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLAttributes, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_add" "', argument " "1"" of type '" "XMLAttributes *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLAttributes_add" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_add" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLAttributes_add" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLAttributes_add" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->add((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_add" "', argument " "1"" of type '" "XMLAttributes *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLAttributes_add" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_add" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLAttributes_add" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->add((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_add__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_add" "', argument " "1"" of type '" "XMLAttributes *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLAttributes_add" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_add" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (int)(arg1)->add((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_add__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLTriple *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_add" "', argument " "1"" of type '" "XMLAttributes *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_add" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_add" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLAttributes_add" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_add" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (int)(arg1)->add((XMLTriple const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLAttributes_add", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLAttributes_add__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLAttributes_add__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_XMLAttributes_add__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[4], (std::basic_string<char>**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_XMLAttributes_add__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLAttributes_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLAttributes::add(std::string const &,std::string const &,std::string const,std::string const)\n"
    "    XMLAttributes::add(std::string const &,std::string const &,std::string const)\n"
    "    XMLAttributes::add(std::string const &,std::string const &)\n"
    "    XMLAttributes::add(XMLTriple const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_removeResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLAttributes_removeResource", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_removeResource" "', argument " "1"" of type '" "XMLAttributes *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLAttributes_removeResource" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->removeResource(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_remove" "', argument " "1"" of type '" "XMLAttributes *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLAttributes_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->remove(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_remove" "', argument " "1"" of type '" "XMLAttributes *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLAttributes_remove" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->remove((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_remove__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_remove" "', argument " "1"" of type '" "XMLAttributes *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_remove__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLTriple *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_remove" "', argument " "1"" of type '" "XMLAttributes *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_remove" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_remove" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  result = (int)(arg1)->remove((XMLTriple const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLAttributes_remove", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLAttributes_remove__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLAttributes_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLAttributes_remove__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLAttributes_remove__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLAttributes_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLAttributes::remove(int)\n"
    "    XMLAttributes::remove(std::string const &,std::string const)\n"
    "    XMLAttributes::remove(std::string const &)\n"
    "    XMLAttributes::remove(XMLTriple const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_clear" "', argument " "1"" of type '" "XMLAttributes *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  result = (int)(arg1)->clear();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getIndex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getIndex" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_getIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_getIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)((XMLAttributes const *)arg1)->getIndex((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getIndex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getIndex" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_getIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_getIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLAttributes_getIndex" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_getIndex" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (int)((XMLAttributes const *)arg1)->getIndex((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getIndex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLTriple *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getIndex" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_getIndex" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_getIndex" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  result = (int)((XMLAttributes const *)arg1)->getIndex((XMLTriple const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLAttributes_getIndex", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLAttributes_getIndex__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLAttributes_getIndex__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLAttributes_getIndex__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLAttributes_getIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLAttributes::getIndex(std::string const &) const\n"
    "    XMLAttributes::getIndex(std::string const &,std::string const &) const\n"
    "    XMLAttributes::getIndex(XMLTriple const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getLength" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  result = (int)((XMLAttributes const *)arg1)->getLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getNumAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getNumAttributes" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  result = (int)((XMLAttributes const *)arg1)->getNumAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLAttributes_getName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getName" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLAttributes_getName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLAttributes const *)arg1)->getName(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLAttributes_getPrefix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getPrefix" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLAttributes_getPrefix" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLAttributes const *)arg1)->getPrefix(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getPrefixedName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLAttributes_getPrefixedName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getPrefixedName" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLAttributes_getPrefixedName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLAttributes const *)arg1)->getPrefixedName(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLAttributes_getURI", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getURI" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLAttributes_getURI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLAttributes const *)arg1)->getURI(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getValue" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLAttributes_getValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLAttributes const *)arg1)->getValue(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getValue" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_getValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_getValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((XMLAttributes const *)arg1)->getValue((std::string const &)*arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getValue__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getValue" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_getValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_getValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLAttributes_getValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_getValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = ((XMLAttributes const *)arg1)->getValue((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getValue__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLTriple *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_getValue" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_getValue" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_getValue" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  result = ((XMLAttributes const *)arg1)->getValue((XMLTriple const &)*arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_getValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLAttributes_getValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLAttributes_getValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLAttributes_getValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLAttributes_getValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLAttributes_getValue__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLAttributes_getValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLAttributes::getValue(int) const\n"
    "    XMLAttributes::getValue(std::string const &) const\n"
    "    XMLAttributes::getValue(std::string const &,std::string const &) const\n"
    "    XMLAttributes::getValue(XMLTriple const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_hasAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_hasAttribute" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLAttributes_hasAttribute" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((XMLAttributes const *)arg1)->hasAttribute(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_hasAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_hasAttribute" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_hasAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_hasAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLAttributes_hasAttribute" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)((XMLAttributes const *)arg1)->hasAttribute((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_hasAttribute__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_hasAttribute" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_hasAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_hasAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((XMLAttributes const *)arg1)->hasAttribute((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_hasAttribute__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  XMLTriple *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_hasAttribute" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLAttributes_hasAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLAttributes_hasAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  result = (bool)((XMLAttributes const *)arg1)->hasAttribute((XMLTriple const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_hasAttribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLAttributes_hasAttribute", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLAttributes_hasAttribute__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLAttributes_hasAttribute__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLAttributes_hasAttribute__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLAttributes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLAttributes_hasAttribute__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLAttributes_hasAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLAttributes::hasAttribute(int) const\n"
    "    XMLAttributes::hasAttribute(std::string const &,std::string const) const\n"
    "    XMLAttributes::hasAttribute(std::string const &) const\n"
    "    XMLAttributes::hasAttribute(XMLTriple const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLAttributes_isEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLAttributes *arg1 = (XMLAttributes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLAttributes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLAttributes_isEmpty" "', argument " "1"" of type '" "XMLAttributes const *""'"); 
  }
  arg1 = reinterpret_cast< XMLAttributes * >(argp1);
  result = (bool)((XMLAttributes const *)arg1)->isEmpty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *XMLAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_XMLAttributes, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XMLAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_XMLNamespaces__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  XMLNamespaces *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (XMLNamespaces *)new XMLNamespaces();
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNamespaces, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_XMLNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLNamespaces" "', argument " "1"" of type '" "XMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNamespaces__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLNamespaces *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLNamespaces,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNamespaces" "', argument " "1"" of type '" "XMLNamespaces const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNamespaces" "', argument " "1"" of type '" "XMLNamespaces const &""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  {
    try {
      result = (XMLNamespaces *)new XMLNamespaces((XMLNamespaces const &)*arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNamespaces, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNamespaces(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_XMLNamespaces", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_XMLNamespaces__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLNamespaces, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLNamespaces__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_XMLNamespaces'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLNamespaces::XMLNamespaces()\n"
    "    XMLNamespaces::XMLNamespaces(XMLNamespaces const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNamespaces *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_clone" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  result = (XMLNamespaces *)((XMLNamespaces const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNamespaces, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_add" "', argument " "1"" of type '" "XMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNamespaces_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNamespaces_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLNamespaces_add" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->add((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_add" "', argument " "1"" of type '" "XMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNamespaces_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNamespaces_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->add((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLNamespaces_add", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLNamespaces_add__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLNamespaces_add__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLNamespaces_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLNamespaces::add(std::string const &,std::string const)\n"
    "    XMLNamespaces::add(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_remove" "', argument " "1"" of type '" "XMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLNamespaces_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->remove(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_remove" "', argument " "1"" of type '" "XMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNamespaces_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNamespaces_remove" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->remove((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLNamespaces_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLNamespaces_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLNamespaces_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLNamespaces_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLNamespaces::remove(int)\n"
    "    XMLNamespaces::remove(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_clear" "', argument " "1"" of type '" "XMLNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  result = (int)(arg1)->clear();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_getIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLNamespaces_getIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_getIndex" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNamespaces_getIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNamespaces_getIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)((XMLNamespaces const *)arg1)->getIndex((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_containsUri(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLNamespaces_containsUri", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_containsUri" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNamespaces_containsUri" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNamespaces_containsUri" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((XMLNamespaces const *)arg1)->containsUri((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_getIndexByPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLNamespaces_getIndexByPrefix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_getIndexByPrefix" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNamespaces_getIndexByPrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNamespaces_getIndexByPrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)((XMLNamespaces const *)arg1)->getIndexByPrefix((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_getLength" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  result = (int)((XMLNamespaces const *)arg1)->getLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_getNumNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_getNumNamespaces" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  result = (int)((XMLNamespaces const *)arg1)->getNumNamespaces();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_getPrefix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_getPrefix" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLNamespaces_getPrefix" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLNamespaces const *)arg1)->getPrefix(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_getPrefix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_getPrefix" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNamespaces_getPrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNamespaces_getPrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((XMLNamespaces const *)arg1)->getPrefix((std::string const &)*arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_getPrefix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLNamespaces_getPrefix", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLNamespaces_getPrefix__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLNamespaces_getPrefix__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLNamespaces_getPrefix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLNamespaces::getPrefix(int) const\n"
    "    XMLNamespaces::getPrefix(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_getURI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_getURI" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLNamespaces_getURI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLNamespaces const *)arg1)->getURI(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_getURI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_getURI" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLNamespaces_getURI" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = ((XMLNamespaces const *)arg1)->getURI(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_getURI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_getURI" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  result = ((XMLNamespaces const *)arg1)->getURI();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_getURI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLNamespaces_getURI", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_XMLNamespaces_getURI__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLNamespaces_getURI__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNamespaces, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLNamespaces_getURI__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLNamespaces_getURI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLNamespaces::getURI(int) const\n"
    "    XMLNamespaces::getURI(std::string const) const\n"
    "    XMLNamespaces::getURI() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_isEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_isEmpty" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  result = (bool)((XMLNamespaces const *)arg1)->isEmpty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_hasURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLNamespaces_hasURI", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_hasURI" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNamespaces_hasURI" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNamespaces_hasURI" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((XMLNamespaces const *)arg1)->hasURI((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_hasPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLNamespaces_hasPrefix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_hasPrefix" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNamespaces_hasPrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNamespaces_hasPrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((XMLNamespaces const *)arg1)->hasPrefix((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNamespaces_hasNS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNamespaces *arg1 = (XMLNamespaces *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLNamespaces_hasNS", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNamespaces_hasNS" "', argument " "1"" of type '" "XMLNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNamespaces * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNamespaces_hasNS" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNamespaces_hasNS" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLNamespaces_hasNS" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNamespaces_hasNS" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)((XMLNamespaces const *)arg1)->hasNS((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *XMLNamespaces_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_XMLNamespaces, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XMLNamespaces_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  XMLToken *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (XMLToken *)new XMLToken();
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNamespaces *arg3 = 0 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLToken" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_XMLNamespaces,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XMLToken" "', argument " "3"" of type '" "XMLNamespaces const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "3"" of type '" "XMLNamespaces const &""'"); 
  }
  arg3 = reinterpret_cast< XMLNamespaces * >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_XMLToken" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_XMLToken" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  {
    try {
      result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,(XMLNamespaces const &)*arg3,arg4,arg5);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNamespaces *arg3 = 0 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLToken" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_XMLNamespaces,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XMLToken" "', argument " "3"" of type '" "XMLNamespaces const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "3"" of type '" "XMLNamespaces const &""'"); 
  }
  arg3 = reinterpret_cast< XMLNamespaces * >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_XMLToken" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,(XMLNamespaces const &)*arg3,arg4);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNamespaces *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLToken" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_XMLNamespaces,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XMLToken" "', argument " "3"" of type '" "XMLNamespaces const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "3"" of type '" "XMLNamespaces const &""'"); 
  }
  arg3 = reinterpret_cast< XMLNamespaces * >(argp3);
  {
    try {
      result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,(XMLNamespaces const &)*arg3);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLToken" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLToken" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_XMLToken" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,arg3,arg4);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLToken" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLToken" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,arg3);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLToken" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  {
    try {
      result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLToken" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLToken" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,arg2,arg3);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLToken" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1,arg2);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  {
    try {
      result = (XMLToken *)new XMLToken((XMLTriple const &)*arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLToken" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLToken" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (XMLToken *)new XMLToken((std::string const &)*arg1,arg2,arg3);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLToken" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (XMLToken *)new XMLToken((std::string const &)*arg1,arg2);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_12(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (XMLToken *)new XMLToken((std::string const &)*arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_XMLToken(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLToken" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken__SWIG_13(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLToken *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLToken,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLToken const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLToken" "', argument " "1"" of type '" "XMLToken const &""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    try {
      result = (XMLToken *)new XMLToken((XMLToken const &)*arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLToken(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_XMLToken", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_XMLToken__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLToken__SWIG_9(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLToken, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLToken__SWIG_13(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLToken__SWIG_12(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_XMLToken__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_XMLToken__SWIG_8(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_XMLToken__SWIG_11(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_XMLNamespaces, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_XMLToken__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_XMLToken__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_XMLToken__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_XMLToken__SWIG_10(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_XMLNamespaces, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_XMLToken__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_XMLToken__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_XMLNamespaces, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_XMLToken__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_XMLToken'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLToken::XMLToken()\n"
    "    XMLToken::XMLToken(XMLTriple const &,XMLAttributes const &,XMLNamespaces const &,unsigned int const,unsigned int const)\n"
    "    XMLToken::XMLToken(XMLTriple const &,XMLAttributes const &,XMLNamespaces const &,unsigned int const)\n"
    "    XMLToken::XMLToken(XMLTriple const &,XMLAttributes const &,XMLNamespaces const &)\n"
    "    XMLToken::XMLToken(XMLTriple const &,XMLAttributes const &,unsigned int const,unsigned int const)\n"
    "    XMLToken::XMLToken(XMLTriple const &,XMLAttributes const &,unsigned int const)\n"
    "    XMLToken::XMLToken(XMLTriple const &,XMLAttributes const &)\n"
    "    XMLToken::XMLToken(XMLTriple const &,unsigned int const,unsigned int const)\n"
    "    XMLToken::XMLToken(XMLTriple const &,unsigned int const)\n"
    "    XMLToken::XMLToken(XMLTriple const &)\n"
    "    XMLToken::XMLToken(std::string const &,unsigned int const,unsigned int const)\n"
    "    XMLToken::XMLToken(std::string const &,unsigned int const)\n"
    "    XMLToken::XMLToken(std::string const &)\n"
    "    XMLToken::XMLToken(XMLToken const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLToken_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLToken *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_clone" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (XMLToken *)((XMLToken const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLAttributes *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttributes" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (XMLAttributes *) &((XMLToken const *)arg1)->getAttributes();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLAttributes, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_setAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLAttributes *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_setAttributes", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_setAttributes" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_setAttributes" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_setAttributes" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  result = (int)(arg1)->setAttributes((XMLAttributes const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_addAttr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_addAttr" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_addAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_addAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLToken_addAttr" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_addAttr" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLToken_addAttr" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLToken_addAttr" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->addAttr((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_addAttr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_addAttr" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_addAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_addAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLToken_addAttr" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_addAttr" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLToken_addAttr" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->addAttr((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_addAttr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_addAttr" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_addAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_addAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLToken_addAttr" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_addAttr" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (int)(arg1)->addAttr((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_addAttr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLTriple *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_addAttr" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_addAttr" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_addAttr" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLToken_addAttr" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_addAttr" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (int)(arg1)->addAttr((XMLTriple const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_addAttr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLToken_addAttr", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLToken_addAttr__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLToken_addAttr__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_XMLToken_addAttr__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[4], (std::basic_string<char>**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_XMLToken_addAttr__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLToken_addAttr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLToken::addAttr(std::string const &,std::string const &,std::string const,std::string const)\n"
    "    XMLToken::addAttr(std::string const &,std::string const &,std::string const)\n"
    "    XMLToken::addAttr(std::string const &,std::string const &)\n"
    "    XMLToken::addAttr(XMLTriple const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLToken_removeAttr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_removeAttr" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLToken_removeAttr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->removeAttr(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_removeAttr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_removeAttr" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_removeAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_removeAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLToken_removeAttr" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->removeAttr((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_removeAttr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_removeAttr" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_removeAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_removeAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->removeAttr((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_removeAttr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLTriple *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_removeAttr" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_removeAttr" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_removeAttr" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  result = (int)(arg1)->removeAttr((XMLTriple const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_removeAttr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLToken_removeAttr", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLToken_removeAttr__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLToken_removeAttr__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLToken_removeAttr__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLToken_removeAttr__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLToken_removeAttr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLToken::removeAttr(int)\n"
    "    XMLToken::removeAttr(std::string const &,std::string const)\n"
    "    XMLToken::removeAttr(std::string const &)\n"
    "    XMLToken::removeAttr(XMLTriple const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLToken_clearAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_clearAttributes" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (int)(arg1)->clearAttributes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrIndex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttrIndex" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_getAttrIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_getAttrIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLToken_getAttrIndex" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)((XMLToken const *)arg1)->getAttrIndex((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrIndex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttrIndex" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_getAttrIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_getAttrIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)((XMLToken const *)arg1)->getAttrIndex((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrIndex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLTriple *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttrIndex" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_getAttrIndex" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_getAttrIndex" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  result = (int)((XMLToken const *)arg1)->getAttrIndex((XMLTriple const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLToken_getAttrIndex", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLToken_getAttrIndex__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLToken_getAttrIndex__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLToken_getAttrIndex__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLToken_getAttrIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLToken::getAttrIndex(std::string const &,std::string const) const\n"
    "    XMLToken::getAttrIndex(std::string const &) const\n"
    "    XMLToken::getAttrIndex(XMLTriple const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttributesLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttributesLength" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (int)((XMLToken const *)arg1)->getAttributesLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_getAttrName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttrName" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLToken_getAttrName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLToken const *)arg1)->getAttrName(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_getAttrPrefix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttrPrefix" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLToken_getAttrPrefix" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLToken const *)arg1)->getAttrPrefix(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrPrefixedName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_getAttrPrefixedName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttrPrefixedName" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLToken_getAttrPrefixedName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLToken const *)arg1)->getAttrPrefixedName(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_getAttrURI", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttrURI" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLToken_getAttrURI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLToken const *)arg1)->getAttrURI(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttrValue" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLToken_getAttrValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLToken const *)arg1)->getAttrValue(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttrValue" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_getAttrValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_getAttrValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLToken_getAttrValue" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = ((XMLToken const *)arg1)->getAttrValue((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrValue__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttrValue" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_getAttrValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_getAttrValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((XMLToken const *)arg1)->getAttrValue((std::string const &)*arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrValue__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLTriple *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getAttrValue" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_getAttrValue" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_getAttrValue" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  result = ((XMLToken const *)arg1)->getAttrValue((XMLTriple const &)*arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getAttrValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLToken_getAttrValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLToken_getAttrValue__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLToken_getAttrValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLToken_getAttrValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLToken_getAttrValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLToken_getAttrValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLToken::getAttrValue(int) const\n"
    "    XMLToken::getAttrValue(std::string const &,std::string const) const\n"
    "    XMLToken::getAttrValue(std::string const &) const\n"
    "    XMLToken::getAttrValue(XMLTriple const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLToken_hasAttr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_hasAttr" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLToken_hasAttr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((XMLToken const *)arg1)->hasAttr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_hasAttr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_hasAttr" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_hasAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_hasAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLToken_hasAttr" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)((XMLToken const *)arg1)->hasAttr((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_hasAttr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_hasAttr" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_hasAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_hasAttr" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((XMLToken const *)arg1)->hasAttr((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_hasAttr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLTriple *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_hasAttr" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_hasAttr" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_hasAttr" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  result = (bool)((XMLToken const *)arg1)->hasAttr((XMLTriple const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_hasAttr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLToken_hasAttr", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLToken_hasAttr__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLToken_hasAttr__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLToken_hasAttr__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLToken_hasAttr__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLToken_hasAttr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLToken::hasAttr(int) const\n"
    "    XMLToken::hasAttr(std::string const &,std::string const) const\n"
    "    XMLToken::hasAttr(std::string const &) const\n"
    "    XMLToken::hasAttr(XMLTriple const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLToken_isAttributesEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_isAttributesEmpty" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (bool)((XMLToken const *)arg1)->isAttributesEmpty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNamespaces *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getNamespaces" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (XMLNamespaces *) &((XMLToken const *)arg1)->getNamespaces();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_setNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLNamespaces *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_setNamespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_setNamespaces" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLNamespaces,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_setNamespaces" "', argument " "2"" of type '" "XMLNamespaces const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_setNamespaces" "', argument " "2"" of type '" "XMLNamespaces const &""'"); 
  }
  arg2 = reinterpret_cast< XMLNamespaces * >(argp2);
  result = (int)(arg1)->setNamespaces((XMLNamespaces const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_addNamespace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_addNamespace" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_addNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_addNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLToken_addNamespace" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->addNamespace((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_addNamespace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_addNamespace" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_addNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_addNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->addNamespace((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_addNamespace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLToken_addNamespace", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLToken_addNamespace__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLToken_addNamespace__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLToken_addNamespace'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLToken::addNamespace(std::string const &,std::string const)\n"
    "    XMLToken::addNamespace(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLToken_removeNamespace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_removeNamespace" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLToken_removeNamespace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->removeNamespace(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_removeNamespace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_removeNamespace" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_removeNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_removeNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->removeNamespace((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_removeNamespace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLToken_removeNamespace", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLToken_removeNamespace__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLToken_removeNamespace__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLToken_removeNamespace'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLToken::removeNamespace(int)\n"
    "    XMLToken::removeNamespace(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLToken_clearNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_clearNamespaces" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (int)(arg1)->clearNamespaces();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getNamespaceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_getNamespaceIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getNamespaceIndex" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_getNamespaceIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_getNamespaceIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)((XMLToken const *)arg1)->getNamespaceIndex((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getNamespaceIndexByPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_getNamespaceIndexByPrefix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getNamespaceIndexByPrefix" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_getNamespaceIndexByPrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_getNamespaceIndexByPrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)((XMLToken const *)arg1)->getNamespaceIndexByPrefix((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getNamespacesLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getNamespacesLength" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (int)((XMLToken const *)arg1)->getNamespacesLength();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getNamespacePrefix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getNamespacePrefix" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLToken_getNamespacePrefix" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLToken const *)arg1)->getNamespacePrefix(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getNamespacePrefix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getNamespacePrefix" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_getNamespacePrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_getNamespacePrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((XMLToken const *)arg1)->getNamespacePrefix((std::string const &)*arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getNamespacePrefix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLToken_getNamespacePrefix", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLToken_getNamespacePrefix__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLToken_getNamespacePrefix__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLToken_getNamespacePrefix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLToken::getNamespacePrefix(int) const\n"
    "    XMLToken::getNamespacePrefix(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLToken_getNamespaceURI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getNamespaceURI" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLToken_getNamespaceURI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((XMLToken const *)arg1)->getNamespaceURI(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getNamespaceURI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getNamespaceURI" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLToken_getNamespaceURI" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = ((XMLToken const *)arg1)->getNamespaceURI(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getNamespaceURI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getNamespaceURI" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = ((XMLToken const *)arg1)->getNamespaceURI();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getNamespaceURI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLToken_getNamespaceURI", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_XMLToken_getNamespaceURI__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLToken_getNamespaceURI__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLToken, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLToken_getNamespaceURI__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLToken_getNamespaceURI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLToken::getNamespaceURI(int) const\n"
    "    XMLToken::getNamespaceURI(std::string const) const\n"
    "    XMLToken::getNamespaceURI() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLToken_isNamespacesEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_isNamespacesEmpty" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (bool)((XMLToken const *)arg1)->isNamespacesEmpty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_hasNamespaceURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_hasNamespaceURI", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_hasNamespaceURI" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_hasNamespaceURI" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_hasNamespaceURI" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((XMLToken const *)arg1)->hasNamespaceURI((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_hasNamespacePrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_hasNamespacePrefix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_hasNamespacePrefix" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_hasNamespacePrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_hasNamespacePrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((XMLToken const *)arg1)->hasNamespacePrefix((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_hasNamespaceNS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_hasNamespaceNS", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_hasNamespaceNS" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_hasNamespaceNS" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_hasNamespaceNS" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLToken_hasNamespaceNS" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_hasNamespaceNS" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)((XMLToken const *)arg1)->hasNamespaceNS((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_setTriple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLTriple *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_setTriple", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_setTriple" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_setTriple" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_setTriple" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  result = (int)(arg1)->setTriple((XMLTriple const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getName" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (std::string *) &((XMLToken const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getPrefix" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (std::string *) &((XMLToken const *)arg1)->getPrefix();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getURI" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (std::string *) &((XMLToken const *)arg1)->getURI();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getCharacters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getCharacters" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (std::string *) &((XMLToken const *)arg1)->getCharacters();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_setCharacters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_setCharacters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_setCharacters" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_setCharacters" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_setCharacters" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setCharacters((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_append" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_append" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_append" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->append((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getColumn" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (unsigned int)((XMLToken const *)arg1)->getColumn();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_getLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_getLine" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (unsigned int)((XMLToken const *)arg1)->getLine();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_isElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_isElement" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (bool)((XMLToken const *)arg1)->isElement();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_isEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_isEnd" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (bool)((XMLToken const *)arg1)->isEnd();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_isEndFor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  XMLToken *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLToken_isEndFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_isEndFor" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLToken,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLToken_isEndFor" "', argument " "2"" of type '" "XMLToken const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLToken_isEndFor" "', argument " "2"" of type '" "XMLToken const &""'"); 
  }
  arg2 = reinterpret_cast< XMLToken * >(argp2);
  result = (bool)((XMLToken const *)arg1)->isEndFor((XMLToken const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_isEOF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_isEOF" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (bool)((XMLToken const *)arg1)->isEOF();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_isStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_isStart" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (bool)((XMLToken const *)arg1)->isStart();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_isText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_isText" "', argument " "1"" of type '" "XMLToken const *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (bool)((XMLToken const *)arg1)->isText();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_setEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_setEnd" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (int)(arg1)->setEnd();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_setEOF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_setEOF" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (int)(arg1)->setEOF();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_unsetEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_unsetEnd" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (int)(arg1)->unsetEnd();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLToken_toString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = (XMLToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLToken_toString" "', argument " "1"" of type '" "XMLToken *""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  result = (arg1)->toString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *XMLToken_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_XMLToken, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XMLToken_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  XMLNode *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (XMLNode *)new XMLNode();
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLToken *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLToken,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLToken const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLToken const &""'"); 
  }
  arg1 = reinterpret_cast< XMLToken * >(argp1);
  {
    try {
      result = (XMLNode *)new XMLNode((XMLToken const &)*arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNamespaces *arg3 = 0 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLNode" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_XMLNamespaces,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XMLNode" "', argument " "3"" of type '" "XMLNamespaces const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "3"" of type '" "XMLNamespaces const &""'"); 
  }
  arg3 = reinterpret_cast< XMLNamespaces * >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_XMLNode" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_XMLNode" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  {
    try {
      result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,(XMLNamespaces const &)*arg3,arg4,arg5);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNamespaces *arg3 = 0 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLNode" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_XMLNamespaces,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XMLNode" "', argument " "3"" of type '" "XMLNamespaces const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "3"" of type '" "XMLNamespaces const &""'"); 
  }
  arg3 = reinterpret_cast< XMLNamespaces * >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_XMLNode" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,(XMLNamespaces const &)*arg3,arg4);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  XMLNamespaces *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLNode" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_XMLNamespaces,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XMLNode" "', argument " "3"" of type '" "XMLNamespaces const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "3"" of type '" "XMLNamespaces const &""'"); 
  }
  arg3 = reinterpret_cast< XMLNamespaces * >(argp3);
  {
    try {
      result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,(XMLNamespaces const &)*arg3);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLNode" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLNode" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_XMLNode" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,arg3,arg4);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLNode" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLNode" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2,arg3);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  XMLAttributes *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLNode" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "2"" of type '" "XMLAttributes const &""'"); 
  }
  arg2 = reinterpret_cast< XMLAttributes * >(argp2);
  {
    try {
      result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,(XMLAttributes const &)*arg2);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLNode" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLNode" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,arg2,arg3);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLNode" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1,arg2);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  {
    try {
      result = (XMLNode *)new XMLNode((XMLTriple const &)*arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLNode" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLNode" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (XMLNode *)new XMLNode((std::string const &)*arg1,arg2,arg3);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_12(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLNode" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (XMLNode *)new XMLNode((std::string const &)*arg1,arg2);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_13(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (XMLNode *)new XMLNode((std::string const &)*arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_14(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLInputStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLInputStream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLInputStream &""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  {
    try {
      result = (XMLNode *)new XMLNode(*arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_XMLNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLNode" "', argument " "1"" of type '" "XMLNode *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode__SWIG_15(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLNode,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLNode const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLNode" "', argument " "1"" of type '" "XMLNode const &""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  {
    try {
      result = (XMLNode *)new XMLNode((XMLNode const &)*arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_XMLNode", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_XMLNode__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLNode, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLNode__SWIG_15(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLNode__SWIG_10(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLInputStream, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLNode__SWIG_14(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLToken, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLNode__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLNode__SWIG_13(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_XMLNode__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_XMLNode__SWIG_9(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_XMLNode__SWIG_12(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_XMLNamespaces, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_XMLNode__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_XMLNode__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_XMLNode__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_XMLNode__SWIG_11(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_XMLNamespaces, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_XMLNode__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_XMLNode__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_XMLNamespaces, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_XMLNode__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_XMLNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLNode::XMLNode()\n"
    "    XMLNode::XMLNode(XMLToken const &)\n"
    "    XMLNode::XMLNode(XMLTriple const &,XMLAttributes const &,XMLNamespaces const &,unsigned int const,unsigned int const)\n"
    "    XMLNode::XMLNode(XMLTriple const &,XMLAttributes const &,XMLNamespaces const &,unsigned int const)\n"
    "    XMLNode::XMLNode(XMLTriple const &,XMLAttributes const &,XMLNamespaces const &)\n"
    "    XMLNode::XMLNode(XMLTriple const &,XMLAttributes const &,unsigned int const,unsigned int const)\n"
    "    XMLNode::XMLNode(XMLTriple const &,XMLAttributes const &,unsigned int const)\n"
    "    XMLNode::XMLNode(XMLTriple const &,XMLAttributes const &)\n"
    "    XMLNode::XMLNode(XMLTriple const &,unsigned int const,unsigned int const)\n"
    "    XMLNode::XMLNode(XMLTriple const &,unsigned int const)\n"
    "    XMLNode::XMLNode(XMLTriple const &)\n"
    "    XMLNode::XMLNode(std::string const &,unsigned int const,unsigned int const)\n"
    "    XMLNode::XMLNode(std::string const &,unsigned int const)\n"
    "    XMLNode::XMLNode(std::string const &)\n"
    "    XMLNode::XMLNode(XMLInputStream &)\n"
    "    XMLNode::XMLNode(XMLNode const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLNode_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_clone" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  result = (XMLNode *)((XMLNode const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_addChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  XMLNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLNode_addChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_addChild" "', argument " "1"" of type '" "XMLNode *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLNode,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNode_addChild" "', argument " "2"" of type '" "XMLNode const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNode_addChild" "', argument " "2"" of type '" "XMLNode const &""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  result = (int)(arg1)->addChild((XMLNode const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_insertChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  unsigned int arg2 ;
  XMLNode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  XMLNode *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLNode_insertChild", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_insertChild" "', argument " "1"" of type '" "XMLNode *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLNode_insertChild" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_XMLNode,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLNode_insertChild" "', argument " "3"" of type '" "XMLNode const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNode_insertChild" "', argument " "3"" of type '" "XMLNode const &""'"); 
  }
  arg3 = reinterpret_cast< XMLNode * >(argp3);
  result = (XMLNode *) &(arg1)->insertChild(arg2,(XMLNode const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_removeChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  XMLNode *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLNode_removeChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_removeChild" "', argument " "1"" of type '" "XMLNode *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLNode_removeChild" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (XMLNode *)(arg1)->removeChild(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_removeChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_removeChildren" "', argument " "1"" of type '" "XMLNode *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  result = (int)(arg1)->removeChildren();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_getChild__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_getChild" "', argument " "1"" of type '" "XMLNode *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLNode_getChild" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (XMLNode *) &(arg1)->getChild(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_getChild__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_getChild" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLNode_getChild" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (XMLNode *) &((XMLNode const *)arg1)->getChild(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_getChild__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_getChild" "', argument " "1"" of type '" "XMLNode *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNode_getChild" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNode_getChild" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (XMLNode *) &(arg1)->getChild((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_getChild__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_getChild" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNode_getChild" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNode_getChild" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (XMLNode *) &((XMLNode const *)arg1)->getChild((std::string const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_getChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLNode_getChild", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLNode_getChild__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_XMLNode_getChild__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLNode_getChild__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLNode_getChild__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLNode_getChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLNode::getChild(unsigned int)\n"
    "    XMLNode::getChild(unsigned int) const\n"
    "    XMLNode::getChild(std::string const &)\n"
    "    XMLNode::getChild(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLNode_getIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLNode_getIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_getIndex" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNode_getIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNode_getIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)((XMLNode const *)arg1)->getIndex((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_hasChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLNode_hasChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_hasChild" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNode_hasChild" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNode_hasChild" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((XMLNode const *)arg1)->hasChild((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_equals__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  XMLNode *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_equals" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLNode,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNode_equals" "', argument " "2"" of type '" "XMLNode const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNode_equals" "', argument " "2"" of type '" "XMLNode const &""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLNode_equals" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XMLNode_equals" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (bool)((XMLNode const *)arg1)->equals((XMLNode const &)*arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_equals__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  XMLNode *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_equals" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLNode,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNode_equals" "', argument " "2"" of type '" "XMLNode const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNode_equals" "', argument " "2"" of type '" "XMLNode const &""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLNode_equals" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)((XMLNode const *)arg1)->equals((XMLNode const &)*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_equals__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  XMLNode *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_equals" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLNode,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNode_equals" "', argument " "2"" of type '" "XMLNode const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNode_equals" "', argument " "2"" of type '" "XMLNode const &""'"); 
  }
  arg2 = reinterpret_cast< XMLNode * >(argp2);
  result = (bool)((XMLNode const *)arg1)->equals((XMLNode const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_equals(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLNode_equals", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLNode, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLNode_equals__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLNode, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLNode_equals__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLNode, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_XMLNode_equals__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLNode_equals'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLNode::equals(XMLNode const &,bool,bool) const\n"
    "    XMLNode::equals(XMLNode const &,bool) const\n"
    "    XMLNode::equals(XMLNode const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLNode_getNumChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_getNumChildren" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  result = (unsigned int)((XMLNode const *)arg1)->getNumChildren();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_writeToStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  XMLOutputStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLNode_writeToStream", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_writeToStream" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLOutputStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNode_writeToStream" "', argument " "2"" of type '" "XMLOutputStream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNode_writeToStream" "', argument " "2"" of type '" "XMLOutputStream &""'"); 
  }
  arg2 = reinterpret_cast< XMLOutputStream * >(argp2);
  ((XMLNode const *)arg1)->writeToStream(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_toXMLString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_toXMLString" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  result = ((XMLNode const *)arg1)->toXMLString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_convertXMLNodeToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_convertXMLNodeToString" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  result = XMLNode::convertXMLNodeToString((XMLNode const *)arg1);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_convertStringToXMLNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  XMLNamespaces *arg2 = (XMLNamespaces *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_convertStringToXMLNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNode_convertStringToXMLNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLNode_convertStringToXMLNode" "', argument " "2"" of type '" "XMLNamespaces const *""'"); 
  }
  arg2 = reinterpret_cast< XMLNamespaces * >(argp2);
  result = (XMLNode *)XMLNode::convertStringToXMLNode((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1,(XMLNamespaces const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_convertStringToXMLNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLNode_convertStringToXMLNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLNode_convertStringToXMLNode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (XMLNode *)XMLNode::convertStringToXMLNode((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLNode_convertStringToXMLNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLNode_convertStringToXMLNode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_XMLNode_convertStringToXMLNode__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLNamespaces, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLNode_convertStringToXMLNode__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLNode_convertStringToXMLNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLNode::convertStringToXMLNode(std::string const &,XMLNamespaces const *)\n"
    "    XMLNode::convertStringToXMLNode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *XMLNode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_XMLNode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XMLNode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_XMLTriple__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  XMLTriple *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (XMLTriple *)new XMLTriple();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLTriple, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLTriple__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  XMLTriple *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLTriple" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLTriple" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XMLTriple" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLTriple" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XMLTriple" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLTriple" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (XMLTriple *)new XMLTriple((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLTriple, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLTriple__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  char arg2 ;
  int res1 = SWIG_OLDOBJ ;
  char val2 ;
  int ecode2 = 0 ;
  XMLTriple *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLTriple" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLTriple" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLTriple" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  result = (XMLTriple *)new XMLTriple((std::string const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLTriple, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLTriple__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  XMLTriple *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLTriple" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLTriple" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (XMLTriple *)new XMLTriple((std::string const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLTriple, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLTriple__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLTriple *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLTriple" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLTriple" "', argument " "1"" of type '" "XMLTriple const &""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  result = (XMLTriple *)new XMLTriple((XMLTriple const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLTriple, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLTriple(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_XMLTriple", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_XMLTriple__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLTriple__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLTriple__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_XMLTriple__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_XMLTriple__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_XMLTriple'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLTriple::XMLTriple()\n"
    "    XMLTriple::XMLTriple(std::string const &,std::string const &,std::string const &)\n"
    "    XMLTriple::XMLTriple(std::string const &,char const)\n"
    "    XMLTriple::XMLTriple(std::string const &)\n"
    "    XMLTriple::XMLTriple(XMLTriple const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_XMLTriple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLTriple, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLTriple" "', argument " "1"" of type '" "XMLTriple *""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTriple_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLTriple *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLTriple, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTriple_clone" "', argument " "1"" of type '" "XMLTriple const *""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  result = (XMLTriple *)((XMLTriple const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLTriple, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTriple_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLTriple, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTriple_getName" "', argument " "1"" of type '" "XMLTriple const *""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  result = (std::string *) &((XMLTriple const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTriple_getPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLTriple, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTriple_getPrefix" "', argument " "1"" of type '" "XMLTriple const *""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  result = (std::string *) &((XMLTriple const *)arg1)->getPrefix();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTriple_getURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLTriple, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTriple_getURI" "', argument " "1"" of type '" "XMLTriple const *""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  result = (std::string *) &((XMLTriple const *)arg1)->getURI();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTriple_getPrefixedName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLTriple, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTriple_getPrefixedName" "', argument " "1"" of type '" "XMLTriple const *""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  result = ((XMLTriple const *)arg1)->getPrefixedName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTriple_isEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLTriple *arg1 = (XMLTriple *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLTriple, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTriple_isEmpty" "', argument " "1"" of type '" "XMLTriple const *""'"); 
  }
  arg1 = reinterpret_cast< XMLTriple * >(argp1);
  result = (bool)((XMLTriple const *)arg1)->isEmpty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *XMLTriple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_XMLTriple, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XMLTriple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_XMLOutputStream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  XMLOutputStream *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLOutputStream" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLOutputStream" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOutputStream" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLOutputStream" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOutputStream" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOutputStream" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (XMLOutputStream *)new XMLOutputStream(*arg1,arg2,arg3,arg4,arg5);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOutputStream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOutputStream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  XMLOutputStream *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLOutputStream" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLOutputStream" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOutputStream" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLOutputStream" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOutputStream" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (XMLOutputStream *)new XMLOutputStream(*arg1,arg2,arg3,arg4);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOutputStream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOutputStream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  XMLOutputStream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLOutputStream" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLOutputStream" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOutputStream" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLOutputStream" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (XMLOutputStream *)new XMLOutputStream(*arg1,arg2,arg3);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOutputStream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOutputStream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLOutputStream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLOutputStream" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLOutputStream" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOutputStream" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (XMLOutputStream *)new XMLOutputStream(*arg1,arg2);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOutputStream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOutputStream__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLOutputStream *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLOutputStream" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLOutputStream" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    try {
      result = (XMLOutputStream *)new XMLOutputStream(*arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOutputStream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOutputStream(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_XMLOutputStream", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLOutputStream__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_XMLOutputStream__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_XMLOutputStream__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_XMLOutputStream__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[4], (std::basic_string<char>**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_XMLOutputStream__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_XMLOutputStream'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLOutputStream::XMLOutputStream(std::ostream &,std::string const,bool,std::string const,std::string const)\n"
    "    XMLOutputStream::XMLOutputStream(std::ostream &,std::string const,bool,std::string const)\n"
    "    XMLOutputStream::XMLOutputStream(std::ostream &,std::string const,bool)\n"
    "    XMLOutputStream::XMLOutputStream(std::ostream &,std::string const)\n"
    "    XMLOutputStream::XMLOutputStream(std::ostream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_XMLOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLOutputStream" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_endElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_endElement" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_endElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_endElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLOutputStream_endElement" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->endElement((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_endElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_endElement" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_endElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_endElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->endElement((std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_endElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_endElement" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_endElement" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_endElement" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLOutputStream_endElement" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->endElement((XMLTriple const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_endElement__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_endElement" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_endElement" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_endElement" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  (arg1)->endElement((XMLTriple const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_endElement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLOutputStream_endElement", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLOutputStream_endElement__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLOutputStream_endElement__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLOutputStream_endElement__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLOutputStream_endElement__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLOutputStream_endElement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLOutputStream::endElement(std::string const &,std::string const)\n"
    "    XMLOutputStream::endElement(std::string const &)\n"
    "    XMLOutputStream::endElement(XMLTriple const &,bool)\n"
    "    XMLOutputStream::endElement(XMLTriple const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_setAutoIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLOutputStream_setAutoIndent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_setAutoIndent" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLOutputStream_setAutoIndent" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAutoIndent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_startElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_startElement" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_startElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_startElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLOutputStream_startElement" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->startElement((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_startElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_startElement" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_startElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_startElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->startElement((std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_startElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_startElement" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_startElement" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_startElement" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  (arg1)->startElement((XMLTriple const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_startElement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLOutputStream_startElement", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLOutputStream_startElement__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLOutputStream_startElement__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLOutputStream_startElement__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLOutputStream_startElement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLOutputStream::startElement(std::string const &,std::string const)\n"
    "    XMLOutputStream::startElement(std::string const &)\n"
    "    XMLOutputStream::startElement(XMLTriple const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_startEndElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_startEndElement" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_startEndElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_startEndElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLOutputStream_startEndElement" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->startEndElement((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_startEndElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_startEndElement" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_startEndElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_startEndElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->startEndElement((std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_startEndElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_startEndElement" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_startEndElement" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_startEndElement" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  (arg1)->startEndElement((XMLTriple const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_startEndElement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLOutputStream_startEndElement", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLOutputStream_startEndElement__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLOutputStream_startEndElement__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLOutputStream_startEndElement__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLOutputStream_startEndElement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLOutputStream::startEndElement(std::string const &,std::string const)\n"
    "    XMLOutputStream::startEndElement(std::string const &)\n"
    "    XMLOutputStream::startEndElement(XMLTriple const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->writeAttribute((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res4 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XMLOutputStream_writeAttribute" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  (arg1)->writeAttribute((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->writeAttribute((XMLTriple const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  (arg1)->writeAttribute((std::string const &)*arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XMLOutputStream_writeAttribute" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  (arg1)->writeAttribute((std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  (arg1)->writeAttribute((XMLTriple const &)*arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  bool *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool temp3 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "bool""'");
  } 
  temp3 = static_cast< bool >(val3);
  arg3 = &temp3;
  (arg1)->writeAttribute((std::string const &)*arg2,(bool const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool temp4 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XMLOutputStream_writeAttribute" "', argument " "4"" of type '" "bool""'");
  } 
  temp4 = static_cast< bool >(val4);
  arg4 = &temp4;
  (arg1)->writeAttribute((std::string const &)*arg2,(std::string const &)*arg3,(bool const &)*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  bool *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool temp3 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "bool""'");
  } 
  temp3 = static_cast< bool >(val3);
  arg3 = &temp3;
  (arg1)->writeAttribute((XMLTriple const &)*arg2,(bool const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "double""'");
  } 
  temp3 = static_cast< double >(val3);
  arg3 = &temp3;
  (arg1)->writeAttribute((std::string const &)*arg2,(double const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double temp4 ;
  double val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XMLOutputStream_writeAttribute" "', argument " "4"" of type '" "double""'");
  } 
  temp4 = static_cast< double >(val4);
  arg4 = &temp4;
  (arg1)->writeAttribute((std::string const &)*arg2,(std::string const &)*arg3,(double const &)*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "double""'");
  } 
  temp3 = static_cast< double >(val3);
  arg3 = &temp3;
  (arg1)->writeAttribute((XMLTriple const &)*arg2,(double const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_12(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  long *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  long temp3 ;
  long val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "long""'");
  } 
  temp3 = static_cast< long >(val3);
  arg3 = &temp3;
  (arg1)->writeAttribute((std::string const &)*arg2,(long const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_13(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  long *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  long temp4 ;
  long val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XMLOutputStream_writeAttribute" "', argument " "4"" of type '" "long""'");
  } 
  temp4 = static_cast< long >(val4);
  arg4 = &temp4;
  (arg1)->writeAttribute((std::string const &)*arg2,(std::string const &)*arg3,(long const &)*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_14(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  long *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  long temp3 ;
  long val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "long""'");
  } 
  temp3 = static_cast< long >(val3);
  arg3 = &temp3;
  (arg1)->writeAttribute((XMLTriple const &)*arg2,(long const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_15(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "int""'");
  } 
  temp3 = static_cast< int >(val3);
  arg3 = &temp3;
  (arg1)->writeAttribute((std::string const &)*arg2,(int const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_16(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int temp4 ;
  int val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XMLOutputStream_writeAttribute" "', argument " "4"" of type '" "int""'");
  } 
  temp4 = static_cast< int >(val4);
  arg4 = &temp4;
  (arg1)->writeAttribute((std::string const &)*arg2,(std::string const &)*arg3,(int const &)*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_17(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "int""'");
  } 
  temp3 = static_cast< int >(val3);
  arg3 = &temp3;
  (arg1)->writeAttribute((XMLTriple const &)*arg2,(int const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute__SWIG_18(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  unsigned int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  unsigned int temp4 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttribute" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttribute" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XMLOutputStream_writeAttribute" "', argument " "4"" of type '" "unsigned int""'");
  } 
  temp4 = static_cast< unsigned int >(val4);
  arg4 = &temp4;
  (arg1)->writeAttribute((std::string const &)*arg2,(std::string const &)*arg3,(unsigned int const &)*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLOutputStream_writeAttribute", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLOutputStream_writeAttribute__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLOutputStream_writeAttribute__SWIG_17(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLOutputStream_writeAttribute__SWIG_14(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLOutputStream_writeAttribute__SWIG_11(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLOutputStream_writeAttribute__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLOutputStream_writeAttribute__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLOutputStream_writeAttribute__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLOutputStream_writeAttribute__SWIG_15(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLOutputStream_writeAttribute__SWIG_12(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLOutputStream_writeAttribute__SWIG_9(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLOutputStream_writeAttribute__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLOutputStream_writeAttribute__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_XMLOutputStream_writeAttribute__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_XMLOutputStream_writeAttribute__SWIG_18(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_XMLOutputStream_writeAttribute__SWIG_16(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_XMLOutputStream_writeAttribute__SWIG_13(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_XMLOutputStream_writeAttribute__SWIG_10(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_XMLOutputStream_writeAttribute__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_XMLOutputStream_writeAttribute__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLOutputStream_writeAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLOutputStream::writeAttribute(std::string const &,std::string const &)\n"
    "    XMLOutputStream::writeAttribute(std::string const &,std::string const &,std::string const &)\n"
    "    XMLOutputStream::writeAttribute(XMLTriple const &,std::string const &)\n"
    "    XMLOutputStream::writeAttribute(std::string const &,char const *)\n"
    "    XMLOutputStream::writeAttribute(std::string const &,std::string const &,char const *)\n"
    "    XMLOutputStream::writeAttribute(XMLTriple const &,char const *)\n"
    "    XMLOutputStream::writeAttribute(std::string const &,bool const &)\n"
    "    XMLOutputStream::writeAttribute(std::string const &,std::string const &,bool const &)\n"
    "    XMLOutputStream::writeAttribute(XMLTriple const &,bool const &)\n"
    "    XMLOutputStream::writeAttribute(std::string const &,double const &)\n"
    "    XMLOutputStream::writeAttribute(std::string const &,std::string const &,double const &)\n"
    "    XMLOutputStream::writeAttribute(XMLTriple const &,double const &)\n"
    "    XMLOutputStream::writeAttribute(std::string const &,long const &)\n"
    "    XMLOutputStream::writeAttribute(std::string const &,std::string const &,long const &)\n"
    "    XMLOutputStream::writeAttribute(XMLTriple const &,long const &)\n"
    "    XMLOutputStream::writeAttribute(std::string const &,int const &)\n"
    "    XMLOutputStream::writeAttribute(std::string const &,std::string const &,int const &)\n"
    "    XMLOutputStream::writeAttribute(XMLTriple const &,int const &)\n"
    "    XMLOutputStream::writeAttribute(std::string const &,std::string const &,unsigned int const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeXMLDecl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeXMLDecl" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  (arg1)->writeXMLDecl();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeComment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeComment" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeComment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeComment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeComment" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeComment" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XMLOutputStream_writeComment" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->writeComment((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeComment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeComment" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeComment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeComment" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLOutputStream_writeComment" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeComment" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->writeComment((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeComment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLOutputStream_writeComment", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLOutputStream_writeComment__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_XMLOutputStream_writeComment__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLOutputStream_writeComment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLOutputStream::writeComment(std::string const &,std::string const &,bool)\n"
    "    XMLOutputStream::writeComment(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_downIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_downIndent" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  (arg1)->downIndent();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_upIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_upIndent" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  (arg1)->upIndent();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_getSBMLNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLNamespaces *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_getSBMLNamespaces" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  result = (SBMLNamespaces *)(arg1)->getSBMLNamespaces();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_setSBMLNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLOutputStream_setSBMLNamespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_setSBMLNamespaces" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_setSBMLNamespaces" "', argument " "2"" of type '" "SBMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces * >(argp2);
  (arg1)->setSBMLNamespaces(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_getWriteComment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLOutputStream_getWriteComment", 0, 0, 0)) SWIG_fail;
  result = (bool)XMLOutputStream::getWriteComment();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_setWriteComment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "XMLOutputStream_setWriteComment" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  XMLOutputStream::setWriteComment(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_getWriteTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLOutputStream_getWriteTimestamp", 0, 0, 0)) SWIG_fail;
  result = (bool)XMLOutputStream::getWriteTimestamp();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_setWriteTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "XMLOutputStream_setWriteTimestamp" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  XMLOutputStream::setWriteTimestamp(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_getLibraryName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLOutputStream_getLibraryName", 0, 0, 0)) SWIG_fail;
  result = XMLOutputStream::getLibraryName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_setLibraryName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_setLibraryName" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_setLibraryName" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  XMLOutputStream::setLibraryName((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_getLibraryVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLOutputStream_getLibraryVersion", 0, 0, 0)) SWIG_fail;
  result = XMLOutputStream::getLibraryVersion();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_setLibraryVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_setLibraryVersion" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_setLibraryVersion" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  XMLOutputStream::setLibraryVersion((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_getIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_getIndent" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  result = (unsigned int)(arg1)->getIndent();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_setIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLOutputStream_setIndent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_setIndent" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLOutputStream_setIndent" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setIndent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttributeBool__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  std::string *arg2 = 0 ;
  bool *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool temp3 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttributeBool" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttributeBool" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttributeBool" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLOutputStream_writeAttributeBool" "', argument " "3"" of type '" "bool""'");
  } 
  temp3 = static_cast< bool >(val3);
  arg3 = &temp3;
  XMLOutputStream_writeAttributeBool__SWIG_0(arg1,(std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg2,(bool const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttributeBool__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLOutputStream *arg1 = (XMLOutputStream *) 0 ;
  XMLTriple *arg2 = 0 ;
  bool *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool temp3 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOutputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLOutputStream_writeAttributeBool" "', argument " "1"" of type '" "XMLOutputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOutputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLTriple,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLOutputStream_writeAttributeBool" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLOutputStream_writeAttributeBool" "', argument " "2"" of type '" "XMLTriple const &""'"); 
  }
  arg2 = reinterpret_cast< XMLTriple * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLOutputStream_writeAttributeBool" "', argument " "3"" of type '" "bool""'");
  } 
  temp3 = static_cast< bool >(val3);
  arg3 = &temp3;
  XMLOutputStream_writeAttributeBool__SWIG_1(arg1,(XMLTriple const &)*arg2,(bool const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLOutputStream_writeAttributeBool(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLOutputStream_writeAttributeBool", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLTriple, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLOutputStream_writeAttributeBool__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLOutputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLOutputStream_writeAttributeBool__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLOutputStream_writeAttributeBool'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLOutputStream::writeAttributeBool(std::string const &,bool const &)\n"
    "    XMLOutputStream::writeAttributeBool(XMLTriple const &,bool const &)\n");
  return 0;
}


SWIGINTERN PyObject *XMLOutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_XMLOutputStream, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XMLOutputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_XMLOwningOutputStringStream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  bool arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  bool val2 ;
  int ecode2 = 0 ;
  XMLOwningOutputStringStream *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputStringStream" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLOwningOutputStringStream" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputStringStream" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputStringStream" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (XMLOwningOutputStringStream *)new XMLOwningOutputStringStream(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOwningOutputStringStream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOwningOutputStringStream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  bool arg2 ;
  std::string arg3 ;
  bool val2 ;
  int ecode2 = 0 ;
  XMLOwningOutputStringStream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputStringStream" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLOwningOutputStringStream" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputStringStream" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (XMLOwningOutputStringStream *)new XMLOwningOutputStringStream(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOwningOutputStringStream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOwningOutputStringStream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  XMLOwningOutputStringStream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputStringStream" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLOwningOutputStringStream" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (XMLOwningOutputStringStream *)new XMLOwningOutputStringStream(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOwningOutputStringStream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOwningOutputStringStream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  XMLOwningOutputStringStream *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputStringStream" "', argument " "1"" of type '" "std::string const""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (XMLOwningOutputStringStream *)new XMLOwningOutputStringStream(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOwningOutputStringStream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOwningOutputStringStream__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  XMLOwningOutputStringStream *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (XMLOwningOutputStringStream *)new XMLOwningOutputStringStream();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOwningOutputStringStream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOwningOutputStringStream(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_XMLOwningOutputStringStream", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_XMLOwningOutputStringStream__SWIG_4(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLOwningOutputStringStream__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_XMLOwningOutputStringStream__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_XMLOwningOutputStringStream__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_XMLOwningOutputStringStream__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_XMLOwningOutputStringStream'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLOwningOutputStringStream::XMLOwningOutputStringStream(std::string const,bool,std::string const,std::string const)\n"
    "    XMLOwningOutputStringStream::XMLOwningOutputStringStream(std::string const,bool,std::string const)\n"
    "    XMLOwningOutputStringStream::XMLOwningOutputStringStream(std::string const,bool)\n"
    "    XMLOwningOutputStringStream::XMLOwningOutputStringStream(std::string const)\n"
    "    XMLOwningOutputStringStream::XMLOwningOutputStringStream()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_XMLOwningOutputStringStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLOwningOutputStringStream *arg1 = (XMLOwningOutputStringStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOwningOutputStringStream, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLOwningOutputStringStream" "', argument " "1"" of type '" "XMLOwningOutputStringStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOwningOutputStringStream * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *XMLOwningOutputStringStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_XMLOwningOutputStringStream, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XMLOwningOutputStringStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_XMLOwningOutputFileStream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int res1 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  XMLOwningOutputFileStream *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLOwningOutputFileStream" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLOwningOutputFileStream" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputFileStream" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLOwningOutputFileStream" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputFileStream" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputFileStream" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (XMLOwningOutputFileStream *)new XMLOwningOutputFileStream((std::string const &)*arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOwningOutputFileStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOwningOutputFileStream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  std::string arg4 ;
  int res1 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  XMLOwningOutputFileStream *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLOwningOutputFileStream" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLOwningOutputFileStream" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputFileStream" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLOwningOutputFileStream" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputFileStream" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (XMLOwningOutputFileStream *)new XMLOwningOutputFileStream((std::string const &)*arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOwningOutputFileStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOwningOutputFileStream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  XMLOwningOutputFileStream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLOwningOutputFileStream" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLOwningOutputFileStream" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputFileStream" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLOwningOutputFileStream" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (XMLOwningOutputFileStream *)new XMLOwningOutputFileStream((std::string const &)*arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOwningOutputFileStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOwningOutputFileStream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  int res1 = SWIG_OLDOBJ ;
  XMLOwningOutputFileStream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLOwningOutputFileStream" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLOwningOutputFileStream" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLOwningOutputFileStream" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (XMLOwningOutputFileStream *)new XMLOwningOutputFileStream((std::string const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOwningOutputFileStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOwningOutputFileStream__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  XMLOwningOutputFileStream *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLOwningOutputFileStream" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLOwningOutputFileStream" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (XMLOwningOutputFileStream *)new XMLOwningOutputFileStream((std::string const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLOwningOutputFileStream, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLOwningOutputFileStream(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_XMLOwningOutputFileStream", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLOwningOutputFileStream__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_XMLOwningOutputFileStream__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_XMLOwningOutputFileStream__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_XMLOwningOutputFileStream__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[4], (std::basic_string<char>**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_XMLOwningOutputFileStream__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_XMLOwningOutputFileStream'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLOwningOutputFileStream::XMLOwningOutputFileStream(std::string const &,std::string const,bool,std::string const,std::string const)\n"
    "    XMLOwningOutputFileStream::XMLOwningOutputFileStream(std::string const &,std::string const,bool,std::string const)\n"
    "    XMLOwningOutputFileStream::XMLOwningOutputFileStream(std::string const &,std::string const,bool)\n"
    "    XMLOwningOutputFileStream::XMLOwningOutputFileStream(std::string const &,std::string const)\n"
    "    XMLOwningOutputFileStream::XMLOwningOutputFileStream(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_XMLOwningOutputFileStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLOwningOutputFileStream *arg1 = (XMLOwningOutputFileStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLOwningOutputFileStream, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLOwningOutputFileStream" "', argument " "1"" of type '" "XMLOwningOutputFileStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLOwningOutputFileStream * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *XMLOwningOutputFileStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_XMLOwningOutputFileStream, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XMLOwningOutputFileStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_XMLInputStream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  bool arg2 ;
  std::string arg3 ;
  XMLErrorLog *arg4 = (XMLErrorLog *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  XMLInputStream *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLInputStream" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLInputStream" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLInputStream" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_XMLInputStream" "', argument " "4"" of type '" "XMLErrorLog *""'"); 
  }
  arg4 = reinterpret_cast< XMLErrorLog * >(argp4);
  result = (XMLInputStream *)new XMLInputStream((char const *)arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLInputStream, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLInputStream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  bool arg2 ;
  std::string arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  XMLInputStream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLInputStream" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLInputStream" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLInputStream" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (XMLInputStream *)new XMLInputStream((char const *)arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLInputStream, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLInputStream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  bool arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  XMLInputStream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLInputStream" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XMLInputStream" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (XMLInputStream *)new XMLInputStream((char const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLInputStream, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLInputStream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  XMLInputStream *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLInputStream" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (XMLInputStream *)new XMLInputStream((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLInputStream, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLInputStream(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_XMLInputStream", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLInputStream__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_XMLInputStream__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_XMLInputStream__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_XMLErrorLog, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_XMLInputStream__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_XMLInputStream'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLInputStream::XMLInputStream(char const *,bool,std::string const,XMLErrorLog *)\n"
    "    XMLInputStream::XMLInputStream(char const *,bool,std::string const)\n"
    "    XMLInputStream::XMLInputStream(char const *,bool)\n"
    "    XMLInputStream::XMLInputStream(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_XMLInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLInputStream" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_getEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_getEncoding" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  result = (std::string *) &(arg1)->getEncoding();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_getVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_getVersion" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  result = (std::string *) &(arg1)->getVersion();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_getErrorLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLErrorLog *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_getErrorLog" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  result = (XMLErrorLog *)(arg1)->getErrorLog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_isEOF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_isEOF" "', argument " "1"" of type '" "XMLInputStream const *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  result = (bool)((XMLInputStream const *)arg1)->isEOF();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_isError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_isError" "', argument " "1"" of type '" "XMLInputStream const *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  result = (bool)((XMLInputStream const *)arg1)->isError();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_isGood(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_isGood" "', argument " "1"" of type '" "XMLInputStream const *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  result = (bool)((XMLInputStream const *)arg1)->isGood();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLToken result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_next" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  result = (arg1)->next();
  resultobj = SWIG_NewPointerObj((new XMLToken(static_cast< const XMLToken& >(result))), SWIGTYPE_p_XMLToken, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLToken *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_peek" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  result = (XMLToken *) &(arg1)->peek();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLToken, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_skipPastEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  XMLToken *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLInputStream_skipPastEnd", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_skipPastEnd" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLToken,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLInputStream_skipPastEnd" "', argument " "2"" of type '" "XMLToken const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLInputStream_skipPastEnd" "', argument " "2"" of type '" "XMLToken const &""'"); 
  }
  arg2 = reinterpret_cast< XMLToken * >(argp2);
  (arg1)->skipPastEnd((XMLToken const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_skipText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_skipText" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  (arg1)->skipText();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_setErrorLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  XMLErrorLog *arg2 = (XMLErrorLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLInputStream_setErrorLog", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_setErrorLog" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLInputStream_setErrorLog" "', argument " "2"" of type '" "XMLErrorLog *""'"); 
  }
  arg2 = reinterpret_cast< XMLErrorLog * >(argp2);
  result = (int)(arg1)->setErrorLog(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_toString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_toString" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  result = (arg1)->toString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_getSBMLNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLNamespaces *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_getSBMLNamespaces" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  result = (SBMLNamespaces *)(arg1)->getSBMLNamespaces();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_setSBMLNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLInputStream_setSBMLNamespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_setSBMLNamespaces" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLInputStream_setSBMLNamespaces" "', argument " "2"" of type '" "SBMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces * >(argp2);
  (arg1)->setSBMLNamespaces(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_determineNumberChildren__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_determineNumberChildren" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLInputStream_determineNumberChildren" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (unsigned int)(arg1)->determineNumberChildren(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_determineNumberChildren__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_determineNumberChildren" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  result = (unsigned int)(arg1)->determineNumberChildren();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_determineNumberChildren(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLInputStream_determineNumberChildren", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLInputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_XMLInputStream_determineNumberChildren__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLInputStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLInputStream_determineNumberChildren__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLInputStream_determineNumberChildren'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLInputStream::determineNumberChildren(std::string const)\n"
    "    XMLInputStream::determineNumberChildren()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_determineNumSpecificChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLInputStream_determineNumSpecificChildren", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_determineNumSpecificChildren" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLInputStream_determineNumSpecificChildren" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLInputStream_determineNumSpecificChildren" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLInputStream_determineNumSpecificChildren" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLInputStream_determineNumSpecificChildren" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (unsigned int)(arg1)->determineNumSpecificChildren((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLInputStream_containsChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLInputStream *arg1 = (XMLInputStream *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLInputStream_containsChild", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLInputStream_containsChild" "', argument " "1"" of type '" "XMLInputStream *""'"); 
  }
  arg1 = reinterpret_cast< XMLInputStream * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLInputStream_containsChild" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLInputStream_containsChild" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLInputStream_containsChild" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLInputStream_containsChild" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->containsChild((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *XMLInputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_XMLInputStream, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XMLInputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_XMLError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  XMLError *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_XMLError" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_XMLError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_XMLError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_XMLError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  {
    try {
      result = (XMLError *)new XMLError(arg1,arg2,arg3,arg4,arg5,arg6);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  XMLError *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_XMLError" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_XMLError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_XMLError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  {
    try {
      result = (XMLError *)new XMLError(arg1,arg2,arg3,arg4,arg5);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  XMLError *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_XMLError" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_XMLError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = (XMLError *)new XMLError(arg1,arg2,arg3,arg4);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  unsigned int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  XMLError *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_XMLError" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (XMLError *)new XMLError(arg1,arg2,arg3);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  XMLError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_XMLError" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_XMLError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (XMLError *)new XMLError(arg1,arg2);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  XMLError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_XMLError" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (XMLError *)new XMLError(arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLError__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  XMLError *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (XMLError *)new XMLError();
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLError__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLError" "', argument " "1"" of type '" "XMLError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLError" "', argument " "1"" of type '" "XMLError const &""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  {
    try {
      result = (XMLError *)new XMLError((XMLError const &)*arg1);
    }
    catch (XMLConstructorException &e) {
      PyErr_SetString(PyExc_ValueError, const_cast<char*>(e.what()));
      return NULL;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_XMLError", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_XMLError__SWIG_6(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLError__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_XMLError__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_XMLError__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_XMLError__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_XMLError__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_XMLError__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_XMLError__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_XMLError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLError::XMLError(int const,std::string const,unsigned int const,unsigned int const,unsigned int const,unsigned int const)\n"
    "    XMLError::XMLError(int const,std::string const,unsigned int const,unsigned int const,unsigned int const)\n"
    "    XMLError::XMLError(int const,std::string const,unsigned int const,unsigned int const)\n"
    "    XMLError::XMLError(int const,std::string const,unsigned int const)\n"
    "    XMLError::XMLError(int const,std::string const)\n"
    "    XMLError::XMLError(int const)\n"
    "    XMLError::XMLError()\n"
    "    XMLError::XMLError(XMLError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_XMLError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLError" "', argument " "1"" of type '" "XMLError *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_getErrorId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_getErrorId" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (unsigned int)((XMLError const *)arg1)->getErrorId();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_getMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_getMessage" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (std::string *) &((XMLError const *)arg1)->getMessage();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_getShortMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_getShortMessage" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (std::string *) &((XMLError const *)arg1)->getShortMessage();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_getLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_getLine" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (unsigned int)((XMLError const *)arg1)->getLine();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_getColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_getColumn" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (unsigned int)((XMLError const *)arg1)->getColumn();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_getSeverity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_getSeverity" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (unsigned int)((XMLError const *)arg1)->getSeverity();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_getSeverityAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_getSeverityAsString" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (std::string *) &((XMLError const *)arg1)->getSeverityAsString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_getCategory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_getCategory" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (unsigned int)((XMLError const *)arg1)->getCategory();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_getCategoryAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_getCategoryAsString" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (std::string *) &((XMLError const *)arg1)->getCategoryAsString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_isInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_isInfo" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (bool)((XMLError const *)arg1)->isInfo();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_isWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_isWarning" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (bool)((XMLError const *)arg1)->isWarning();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_isError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_isError" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (bool)((XMLError const *)arg1)->isError();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_isFatal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_isFatal" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (bool)((XMLError const *)arg1)->isFatal();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_isInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_isInternal" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (bool)((XMLError const *)arg1)->isInternal();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_isSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_isSystem" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (bool)((XMLError const *)arg1)->isSystem();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_isXML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_isXML" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (bool)((XMLError const *)arg1)->isXML();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_isValid" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (bool)((XMLError const *)arg1)->isValid();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_setLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLError_setLine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_setLine" "', argument " "1"" of type '" "XMLError *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLError_setLine" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->setLine(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_setColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLError_setColumn", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_setColumn" "', argument " "1"" of type '" "XMLError *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLError_setColumn" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->setColumn(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_getStandardMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "XMLError_getStandardMessage" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = XMLError::getStandardMessage(arg1);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_getPackage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_getPackage" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (std::string *) &((XMLError const *)arg1)->getPackage();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLError_getErrorIdOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLError *arg1 = (XMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLError_getErrorIdOffset" "', argument " "1"" of type '" "XMLError const *""'"); 
  }
  arg1 = reinterpret_cast< XMLError * >(argp1);
  result = (unsigned int)((XMLError const *)arg1)->getErrorIdOffset();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *XMLError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_XMLError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XMLError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_XMLErrorLog_getNumErrors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_getNumErrors" "', argument " "1"" of type '" "XMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  result = (unsigned int)((XMLErrorLog const *)arg1)->getNumErrors();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_getError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  XMLError *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLErrorLog_getError", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_getError" "', argument " "1"" of type '" "XMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLErrorLog_getError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (XMLError *)((XMLErrorLog const *)arg1)->getError(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLError, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_clearLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_clearLog" "', argument " "1"" of type '" "XMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  (arg1)->clearLog();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLErrorLog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  XMLErrorLog *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (XMLErrorLog *)new XMLErrorLog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLErrorLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLErrorLog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLErrorLog *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLErrorLog,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLErrorLog" "', argument " "1"" of type '" "XMLErrorLog const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLErrorLog" "', argument " "1"" of type '" "XMLErrorLog const &""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  result = (XMLErrorLog *)new XMLErrorLog((XMLErrorLog const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLErrorLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLErrorLog(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_XMLErrorLog", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_XMLErrorLog__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLErrorLog, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XMLErrorLog__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_XMLErrorLog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLErrorLog::XMLErrorLog()\n"
    "    XMLErrorLog::XMLErrorLog(XMLErrorLog const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_XMLErrorLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLErrorLog" "', argument " "1"" of type '" "XMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  XMLError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_add" "', argument " "1"" of type '" "XMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLError,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLErrorLog_add" "', argument " "2"" of type '" "XMLError const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLErrorLog_add" "', argument " "2"" of type '" "XMLError const &""'"); 
  }
  arg2 = reinterpret_cast< XMLError * >(argp2);
  (arg1)->add((XMLError const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  std::vector< XMLError * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_add" "', argument " "1"" of type '" "XMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_XMLError_p_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLErrorLog_add" "', argument " "2"" of type '" "std::vector< XMLError * > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLErrorLog_add" "', argument " "2"" of type '" "std::vector< XMLError * > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< XMLError * > * >(argp2);
  (arg1)->add((std::vector< XMLError * > const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLErrorLog_add", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLError, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLErrorLog_add__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_XMLError_p_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLErrorLog_add__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLErrorLog_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLErrorLog::add(XMLError const &)\n"
    "    XMLErrorLog::add(std::vector< XMLError * > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_toString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_toString" "', argument " "1"" of type '" "XMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  result = ((XMLErrorLog const *)arg1)->toString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_printErrors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_printErrors" "', argument " "1"" of type '" "XMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLErrorLog_printErrors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLErrorLog_printErrors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ((XMLErrorLog const *)arg1)->printErrors(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_printErrors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_printErrors" "', argument " "1"" of type '" "XMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  ((XMLErrorLog const *)arg1)->printErrors();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_printErrors__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  std::ostream *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_printErrors" "', argument " "1"" of type '" "XMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLErrorLog_printErrors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLErrorLog_printErrors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLErrorLog_printErrors" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ((XMLErrorLog const *)arg1)->printErrors(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_printErrors(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLErrorLog_printErrors", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_XMLErrorLog_printErrors__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLErrorLog_printErrors__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLErrorLog_printErrors__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLErrorLog_printErrors'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLErrorLog::printErrors(std::ostream &) const\n"
    "    XMLErrorLog::printErrors() const\n"
    "    XMLErrorLog::printErrors(std::ostream &,unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_isSeverityOverridden(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_isSeverityOverridden" "', argument " "1"" of type '" "XMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  result = (bool)((XMLErrorLog const *)arg1)->isSeverityOverridden();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_unsetSeverityOverride(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_unsetSeverityOverride" "', argument " "1"" of type '" "XMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  (arg1)->unsetSeverityOverride();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_getSeverityOverride(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLErrorSeverityOverride_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_getSeverityOverride" "', argument " "1"" of type '" "XMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  result = (XMLErrorSeverityOverride_t)((XMLErrorLog const *)arg1)->getSeverityOverride();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_setSeverityOverride(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  XMLErrorSeverityOverride_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLErrorLog_setSeverityOverride", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_setSeverityOverride" "', argument " "1"" of type '" "XMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLErrorLog_setSeverityOverride" "', argument " "2"" of type '" "XMLErrorSeverityOverride_t""'");
  } 
  arg2 = static_cast< XMLErrorSeverityOverride_t >(val2);
  (arg1)->setSeverityOverride(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_changeErrorSeverity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  XMLErrorSeverity_t arg2 ;
  XMLErrorSeverity_t arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_changeErrorSeverity" "', argument " "1"" of type '" "XMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLErrorLog_changeErrorSeverity" "', argument " "2"" of type '" "XMLErrorSeverity_t""'");
  } 
  arg2 = static_cast< XMLErrorSeverity_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLErrorLog_changeErrorSeverity" "', argument " "3"" of type '" "XMLErrorSeverity_t""'");
  } 
  arg3 = static_cast< XMLErrorSeverity_t >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLErrorLog_changeErrorSeverity" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->changeErrorSeverity(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_changeErrorSeverity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  XMLErrorSeverity_t arg2 ;
  XMLErrorSeverity_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_changeErrorSeverity" "', argument " "1"" of type '" "XMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLErrorLog_changeErrorSeverity" "', argument " "2"" of type '" "XMLErrorSeverity_t""'");
  } 
  arg2 = static_cast< XMLErrorSeverity_t >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XMLErrorLog_changeErrorSeverity" "', argument " "3"" of type '" "XMLErrorSeverity_t""'");
  } 
  arg3 = static_cast< XMLErrorSeverity_t >(val3);
  (arg1)->changeErrorSeverity(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_changeErrorSeverity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "XMLErrorLog_changeErrorSeverity", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_XMLErrorLog_changeErrorSeverity__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_XMLErrorLog_changeErrorSeverity__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'XMLErrorLog_changeErrorSeverity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    XMLErrorLog::changeErrorSeverity(XMLErrorSeverity_t,XMLErrorSeverity_t,std::string)\n"
    "    XMLErrorLog::changeErrorSeverity(XMLErrorSeverity_t,XMLErrorSeverity_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLErrorLog_contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLErrorLog *arg1 = (XMLErrorLog *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "XMLErrorLog_contains", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLErrorLog_contains" "', argument " "1"" of type '" "XMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< XMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XMLErrorLog_contains" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (bool)((XMLErrorLog const *)arg1)->contains(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *XMLErrorLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_XMLErrorLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XMLErrorLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLErrorLog_getError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SBMLError *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLErrorLog_getError", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_getError" "', argument " "1"" of type '" "SBMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_getError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBMLError *)((SBMLErrorLog const *)arg1)->getError(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_getErrorWithSeverity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SBMLError *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLErrorLog_getErrorWithSeverity", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_getErrorWithSeverity" "', argument " "1"" of type '" "SBMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_getErrorWithSeverity" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_getErrorWithSeverity" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (SBMLError *)((SBMLErrorLog const *)arg1)->getErrorWithSeverity(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_getNumFailsWithSeverity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_getNumFailsWithSeverity" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_getNumFailsWithSeverity" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (unsigned int)(arg1)->getNumFailsWithSeverity(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_getNumFailsWithSeverity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_getNumFailsWithSeverity" "', argument " "1"" of type '" "SBMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_getNumFailsWithSeverity" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (unsigned int)((SBMLErrorLog const *)arg1)->getNumFailsWithSeverity(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_getNumFailsWithSeverity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLErrorLog_getNumFailsWithSeverity", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBMLErrorLog_getNumFailsWithSeverity__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBMLErrorLog_getNumFailsWithSeverity__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLErrorLog_getNumFailsWithSeverity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLErrorLog::getNumFailsWithSeverity(unsigned int)\n"
    "    SBMLErrorLog::getNumFailsWithSeverity(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_SBMLErrorLog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLErrorLog *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLErrorLog *)new SBMLErrorLog();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLErrorLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLErrorLog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLErrorLog *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLErrorLog,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLErrorLog" "', argument " "1"" of type '" "SBMLErrorLog const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLErrorLog" "', argument " "1"" of type '" "SBMLErrorLog const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  result = (SBMLErrorLog *)new SBMLErrorLog((SBMLErrorLog const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLErrorLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLErrorLog(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLErrorLog", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLErrorLog__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLErrorLog, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLErrorLog__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLErrorLog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLErrorLog::SBMLErrorLog()\n"
    "    SBMLErrorLog::SBMLErrorLog(SBMLErrorLog const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMLErrorLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLErrorLog" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  std::string arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int arg8 ;
  unsigned int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  unsigned int val9 ;
  int ecode9 = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_logError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logError" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBMLErrorLog_logError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SBMLErrorLog_logError" "', argument " "7"" of type '" "unsigned int""'");
  } 
  arg7 = static_cast< unsigned int >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SBMLErrorLog_logError" "', argument " "8"" of type '" "unsigned int""'");
  } 
  arg8 = static_cast< unsigned int >(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SBMLErrorLog_logError" "', argument " "9"" of type '" "unsigned int""'");
  } 
  arg9 = static_cast< unsigned int >(val9);
  (arg1)->logError(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  std::string arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_logError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logError" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBMLErrorLog_logError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SBMLErrorLog_logError" "', argument " "7"" of type '" "unsigned int""'");
  } 
  arg7 = static_cast< unsigned int >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SBMLErrorLog_logError" "', argument " "8"" of type '" "unsigned int""'");
  } 
  arg8 = static_cast< unsigned int >(val8);
  (arg1)->logError(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  std::string arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_logError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logError" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBMLErrorLog_logError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SBMLErrorLog_logError" "', argument " "7"" of type '" "unsigned int""'");
  } 
  arg7 = static_cast< unsigned int >(val7);
  (arg1)->logError(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  std::string arg5 ;
  unsigned int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_logError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logError" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBMLErrorLog_logError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  (arg1)->logError(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_logError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logError" "', argument " "5"" of type '" "std::string const""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->logError(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_logError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  (arg1)->logError(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logError__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_logError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  (arg1)->logError(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logError__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_logError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->logError(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logError__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  (arg1)->logError();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLErrorLog_logError", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLErrorLog_logError__SWIG_8(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SBMLErrorLog_logError__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBMLErrorLog_logError__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBMLErrorLog_logError__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[4], (std::basic_string<char>**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SBMLErrorLog_logError__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[4], (std::basic_string<char>**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SBMLErrorLog_logError__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[4], (std::basic_string<char>**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SBMLErrorLog_logError__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[4], (std::basic_string<char>**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SBMLErrorLog_logError__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[4], (std::basic_string<char>**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_unsigned_SS_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_SBMLErrorLog_logError__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLErrorLog_logError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLErrorLog::logError(unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const,unsigned int const,unsigned int const,unsigned int const)\n"
    "    SBMLErrorLog::logError(unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const,unsigned int const,unsigned int const)\n"
    "    SBMLErrorLog::logError(unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const,unsigned int const)\n"
    "    SBMLErrorLog::logError(unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const)\n"
    "    SBMLErrorLog::logError(unsigned int const,unsigned int const,unsigned int const,std::string const)\n"
    "    SBMLErrorLog::logError(unsigned int const,unsigned int const,unsigned int const)\n"
    "    SBMLErrorLog::logError(unsigned int const,unsigned int const)\n"
    "    SBMLErrorLog::logError(unsigned int const)\n"
    "    SBMLErrorLog::logError()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logPackageError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  std::string arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  std::string arg7 ;
  unsigned int arg8 ;
  unsigned int arg9 ;
  unsigned int arg10 ;
  unsigned int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  unsigned int val9 ;
  int ecode9 = 0 ;
  unsigned int val10 ;
  int ecode10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logPackageError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logPackageError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logPackageError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBMLErrorLog_logPackageError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBMLErrorLog_logPackageError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SBMLErrorLog_logPackageError" "', argument " "8"" of type '" "unsigned int""'");
  } 
  arg8 = static_cast< unsigned int >(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SBMLErrorLog_logPackageError" "', argument " "9"" of type '" "unsigned int""'");
  } 
  arg9 = static_cast< unsigned int >(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SBMLErrorLog_logPackageError" "', argument " "10"" of type '" "unsigned int""'");
  } 
  arg10 = static_cast< unsigned int >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SBMLErrorLog_logPackageError" "', argument " "11"" of type '" "unsigned int""'");
  } 
  arg11 = static_cast< unsigned int >(val11);
  (arg1)->logPackageError(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logPackageError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  std::string arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  std::string arg7 ;
  unsigned int arg8 ;
  unsigned int arg9 ;
  unsigned int arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  unsigned int val9 ;
  int ecode9 = 0 ;
  unsigned int val10 ;
  int ecode10 = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logPackageError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logPackageError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logPackageError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBMLErrorLog_logPackageError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBMLErrorLog_logPackageError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SBMLErrorLog_logPackageError" "', argument " "8"" of type '" "unsigned int""'");
  } 
  arg8 = static_cast< unsigned int >(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SBMLErrorLog_logPackageError" "', argument " "9"" of type '" "unsigned int""'");
  } 
  arg9 = static_cast< unsigned int >(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SBMLErrorLog_logPackageError" "', argument " "10"" of type '" "unsigned int""'");
  } 
  arg10 = static_cast< unsigned int >(val10);
  (arg1)->logPackageError(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logPackageError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  std::string arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  std::string arg7 ;
  unsigned int arg8 ;
  unsigned int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  unsigned int val9 ;
  int ecode9 = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logPackageError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logPackageError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logPackageError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBMLErrorLog_logPackageError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBMLErrorLog_logPackageError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SBMLErrorLog_logPackageError" "', argument " "8"" of type '" "unsigned int""'");
  } 
  arg8 = static_cast< unsigned int >(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SBMLErrorLog_logPackageError" "', argument " "9"" of type '" "unsigned int""'");
  } 
  arg9 = static_cast< unsigned int >(val9);
  (arg1)->logPackageError(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logPackageError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  std::string arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  std::string arg7 ;
  unsigned int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logPackageError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logPackageError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logPackageError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBMLErrorLog_logPackageError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBMLErrorLog_logPackageError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SBMLErrorLog_logPackageError" "', argument " "8"" of type '" "unsigned int""'");
  } 
  arg8 = static_cast< unsigned int >(val8);
  (arg1)->logPackageError(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logPackageError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  std::string arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logPackageError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logPackageError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logPackageError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBMLErrorLog_logPackageError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBMLErrorLog_logPackageError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "7"" of type '" "std::string const""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->logPackageError(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logPackageError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  std::string arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logPackageError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logPackageError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logPackageError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBMLErrorLog_logPackageError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBMLErrorLog_logPackageError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  (arg1)->logPackageError(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logPackageError__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  std::string arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logPackageError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logPackageError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logPackageError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBMLErrorLog_logPackageError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  (arg1)->logPackageError(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logPackageError__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  std::string arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logPackageError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logPackageError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLErrorLog_logPackageError" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  (arg1)->logPackageError(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logPackageError__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  std::string arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logPackageError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLErrorLog_logPackageError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  (arg1)->logPackageError(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logPackageError__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logPackageError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SBMLErrorLog_logPackageError" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->logPackageError(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logPackageError__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_logPackageError" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  (arg1)->logPackageError();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_logPackageError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBMLErrorLog_logPackageError", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBMLErrorLog_logPackageError__SWIG_10(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBMLErrorLog_logPackageError__SWIG_9(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SBMLErrorLog_logPackageError__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SBMLErrorLog_logPackageError__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SBMLErrorLog_logPackageError__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SBMLErrorLog_logPackageError__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[6], (std::basic_string<char>**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SBMLErrorLog_logPackageError__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[6], (std::basic_string<char>**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SBMLErrorLog_logPackageError__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[6], (std::basic_string<char>**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_unsigned_SS_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_SBMLErrorLog_logPackageError__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[6], (std::basic_string<char>**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_unsigned_SS_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_SBMLErrorLog_logPackageError__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBMLErrorLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[6], (std::basic_string<char>**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_unsigned_SS_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_SBMLErrorLog_logPackageError__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBMLErrorLog_logPackageError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLErrorLog::logPackageError(std::string const,unsigned int const,unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const,unsigned int const,unsigned int const,unsigned int const)\n"
    "    SBMLErrorLog::logPackageError(std::string const,unsigned int const,unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const,unsigned int const,unsigned int const)\n"
    "    SBMLErrorLog::logPackageError(std::string const,unsigned int const,unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const,unsigned int const)\n"
    "    SBMLErrorLog::logPackageError(std::string const,unsigned int const,unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const)\n"
    "    SBMLErrorLog::logPackageError(std::string const,unsigned int const,unsigned int const,unsigned int const,unsigned int const,std::string const)\n"
    "    SBMLErrorLog::logPackageError(std::string const,unsigned int const,unsigned int const,unsigned int const,unsigned int const)\n"
    "    SBMLErrorLog::logPackageError(std::string const,unsigned int const,unsigned int const,unsigned int const)\n"
    "    SBMLErrorLog::logPackageError(std::string const,unsigned int const,unsigned int const)\n"
    "    SBMLErrorLog::logPackageError(std::string const,unsigned int const)\n"
    "    SBMLErrorLog::logPackageError(std::string const)\n"
    "    SBMLErrorLog::logPackageError()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  SBMLError *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLErrorLog_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_add" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SBMLError,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLErrorLog_add" "', argument " "2"" of type '" "SBMLError const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLErrorLog_add" "', argument " "2"" of type '" "SBMLError const &""'"); 
  }
  arg2 = reinterpret_cast< SBMLError * >(argp2);
  (arg1)->add((SBMLError const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLErrorLog_remove", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_remove" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->remove(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_removeAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLErrorLog_removeAll", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_removeAll" "', argument " "1"" of type '" "SBMLErrorLog *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_removeAll" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->removeAll(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLErrorLog_contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLErrorLog *arg1 = (SBMLErrorLog *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLErrorLog_contains", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLErrorLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLErrorLog_contains" "', argument " "1"" of type '" "SBMLErrorLog const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLErrorLog * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLErrorLog_contains" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (bool)((SBMLErrorLog const *)arg1)->contains(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLErrorLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLErrorLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLErrorLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SBMLError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int arg8 ;
  std::string arg9 ;
  unsigned int arg10 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  unsigned int val10 ;
  int ecode10 = 0 ;
  SBMLError *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLError" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBMLError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SBMLError" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SBMLError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SBMLError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SBMLError" "', argument " "7"" of type '" "unsigned int""'");
  } 
  arg7 = static_cast< unsigned int >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SBMLError" "', argument " "8"" of type '" "unsigned int""'");
  } 
  arg8 = static_cast< unsigned int >(val8);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SBMLError" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_unsigned_SS_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SBMLError" "', argument " "10"" of type '" "unsigned int""'");
  } 
  arg10 = static_cast< unsigned int >(val10);
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int arg8 ;
  std::string arg9 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  SBMLError *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLError" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBMLError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SBMLError" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SBMLError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SBMLError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SBMLError" "', argument " "7"" of type '" "unsigned int""'");
  } 
  arg7 = static_cast< unsigned int >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SBMLError" "', argument " "8"" of type '" "unsigned int""'");
  } 
  arg8 = static_cast< unsigned int >(val8);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SBMLError" "', argument " "9"" of type '" "std::string const""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int arg8 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  SBMLError *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLError" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBMLError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SBMLError" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SBMLError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SBMLError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SBMLError" "', argument " "7"" of type '" "unsigned int""'");
  } 
  arg7 = static_cast< unsigned int >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SBMLError" "', argument " "8"" of type '" "unsigned int""'");
  } 
  arg8 = static_cast< unsigned int >(val8);
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  SBMLError *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLError" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBMLError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SBMLError" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SBMLError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SBMLError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SBMLError" "', argument " "7"" of type '" "unsigned int""'");
  } 
  arg7 = static_cast< unsigned int >(val7);
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  SBMLError *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLError" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBMLError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SBMLError" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SBMLError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SBMLError" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string arg4 ;
  unsigned int arg5 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  SBMLError *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLError" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBMLError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SBMLError" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SBMLError" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLError__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string arg4 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  SBMLError *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLError" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBMLError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SBMLError" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLError__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  SBMLError *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLError" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBMLError" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (SBMLError *)new SBMLError(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLError__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SBMLError *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLError" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBMLError" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SBMLError *)new SBMLError(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLError__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  SBMLError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBMLError" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (SBMLError *)new SBMLError(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLError__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SBMLError *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (SBMLError *)new SBMLError();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLError__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLError *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLError *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLError,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLError" "', argument " "1"" of type '" "SBMLError const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLError" "', argument " "1"" of type '" "SBMLError const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLError * >(argp1);
  result = (SBMLError *)new SBMLError((SBMLError const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLError", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SBMLError__SWIG_10(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLError, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLError__SWIG_11(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SBMLError__SWIG_9(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBMLError__SWIG_8(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SBMLError__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SBMLError__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SBMLError__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SBMLError__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_SBMLError__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_SBMLError__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[8], (std::basic_string<char>**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_SBMLError__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[3], (std::basic_string<char>**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[8], (std::basic_string<char>**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_SBMLError__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLError::SBMLError(unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const,unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const)\n"
    "    SBMLError::SBMLError(unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const,unsigned int const,unsigned int const,unsigned int const,std::string const)\n"
    "    SBMLError::SBMLError(unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const,unsigned int const,unsigned int const,unsigned int const)\n"
    "    SBMLError::SBMLError(unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const,unsigned int const,unsigned int const)\n"
    "    SBMLError::SBMLError(unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const,unsigned int const)\n"
    "    SBMLError::SBMLError(unsigned int const,unsigned int const,unsigned int const,std::string const,unsigned int const)\n"
    "    SBMLError::SBMLError(unsigned int const,unsigned int const,unsigned int const,std::string const)\n"
    "    SBMLError::SBMLError(unsigned int const,unsigned int const,unsigned int const)\n"
    "    SBMLError::SBMLError(unsigned int const,unsigned int const)\n"
    "    SBMLError::SBMLError(unsigned int const)\n"
    "    SBMLError::SBMLError()\n"
    "    SBMLError::SBMLError(SBMLError const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMLError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLError *arg1 = (SBMLError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLError" "', argument " "1"" of type '" "SBMLError *""'"); 
  }
  arg1 = reinterpret_cast< SBMLError * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CVTerm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QualifierType_t arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  CVTerm *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CVTerm" "', argument " "1"" of type '" "QualifierType_t""'");
  } 
  arg1 = static_cast< QualifierType_t >(val1);
  result = (CVTerm *)new CVTerm(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CVTerm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  CVTerm *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (CVTerm *)new CVTerm();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CVTerm__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  CVTerm *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLNode,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CVTerm" "', argument " "1"" of type '" "XMLNode const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CVTerm" "', argument " "1"" of type '" "XMLNode const""'");
    } else {
      XMLNode * temp = reinterpret_cast< XMLNode * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (CVTerm *)new CVTerm(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CVTerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CVTerm" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CVTerm__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  CVTerm *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_CVTerm,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CVTerm" "', argument " "1"" of type '" "CVTerm const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CVTerm" "', argument " "1"" of type '" "CVTerm const &""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (CVTerm *)new CVTerm((CVTerm const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CVTerm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CVTerm", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CVTerm__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLNode, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CVTerm__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_CVTerm, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CVTerm__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CVTerm__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CVTerm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CVTerm::CVTerm(QualifierType_t)\n"
    "    CVTerm::CVTerm()\n"
    "    CVTerm::CVTerm(XMLNode const)\n"
    "    CVTerm::CVTerm(CVTerm const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CVTerm_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CVTerm *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_clone" "', argument " "1"" of type '" "CVTerm const *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (CVTerm *)((CVTerm const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getQualifierType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  QualifierType_t result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getQualifierType" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (QualifierType_t)(arg1)->getQualifierType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getQualifierType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  QualifierType_t result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getQualifierType" "', argument " "1"" of type '" "CVTerm const *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (QualifierType_t)((CVTerm const *)arg1)->getQualifierType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getQualifierType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CVTerm_getQualifierType", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_getQualifierType__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_getQualifierType__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CVTerm_getQualifierType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CVTerm::getQualifierType()\n"
    "    CVTerm::getQualifierType() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CVTerm_getModelQualifierType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ModelQualifierType_t result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getModelQualifierType" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (ModelQualifierType_t)(arg1)->getModelQualifierType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getModelQualifierType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ModelQualifierType_t result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getModelQualifierType" "', argument " "1"" of type '" "CVTerm const *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (ModelQualifierType_t)((CVTerm const *)arg1)->getModelQualifierType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getModelQualifierType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CVTerm_getModelQualifierType", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_getModelQualifierType__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_getModelQualifierType__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CVTerm_getModelQualifierType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CVTerm::getModelQualifierType()\n"
    "    CVTerm::getModelQualifierType() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CVTerm_getBiologicalQualifierType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  BiolQualifierType_t result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getBiologicalQualifierType" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (BiolQualifierType_t)(arg1)->getBiologicalQualifierType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getBiologicalQualifierType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  BiolQualifierType_t result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getBiologicalQualifierType" "', argument " "1"" of type '" "CVTerm const *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (BiolQualifierType_t)((CVTerm const *)arg1)->getBiologicalQualifierType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getBiologicalQualifierType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CVTerm_getBiologicalQualifierType", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_getBiologicalQualifierType__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_getBiologicalQualifierType__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CVTerm_getBiologicalQualifierType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CVTerm::getBiologicalQualifierType()\n"
    "    CVTerm::getBiologicalQualifierType() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CVTerm_getResources__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLAttributes *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getResources" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (XMLAttributes *)(arg1)->getResources();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLAttributes, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getResources__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  XMLAttributes *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getResources" "', argument " "1"" of type '" "CVTerm const *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (XMLAttributes *)((CVTerm const *)arg1)->getResources();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLAttributes, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getResources(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CVTerm_getResources", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_getResources__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_getResources__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CVTerm_getResources'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CVTerm::getResources()\n"
    "    CVTerm::getResources() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CVTerm_getNumResources__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getNumResources" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (unsigned int)(arg1)->getNumResources();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getNumResources__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getNumResources" "', argument " "1"" of type '" "CVTerm const *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (unsigned int)((CVTerm const *)arg1)->getNumResources();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getNumResources(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CVTerm_getNumResources", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_getNumResources__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_getNumResources__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CVTerm_getNumResources'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CVTerm::getNumResources()\n"
    "    CVTerm::getNumResources() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CVTerm_getResourceURI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getResourceURI" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CVTerm_getResourceURI" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (arg1)->getResourceURI(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getResourceURI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getResourceURI" "', argument " "1"" of type '" "CVTerm const *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CVTerm_getResourceURI" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = ((CVTerm const *)arg1)->getResourceURI(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getResourceURI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CVTerm_getResourceURI", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CVTerm_getResourceURI__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CVTerm_getResourceURI__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CVTerm_getResourceURI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CVTerm::getResourceURI(unsigned int)\n"
    "    CVTerm::getResourceURI(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CVTerm_setQualifierType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  QualifierType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "CVTerm_setQualifierType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_setQualifierType" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CVTerm_setQualifierType" "', argument " "2"" of type '" "QualifierType_t""'");
  } 
  arg2 = static_cast< QualifierType_t >(val2);
  result = (int)(arg1)->setQualifierType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_setModelQualifierType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  ModelQualifierType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_setModelQualifierType" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CVTerm_setModelQualifierType" "', argument " "2"" of type '" "ModelQualifierType_t""'");
  } 
  arg2 = static_cast< ModelQualifierType_t >(val2);
  result = (int)(arg1)->setModelQualifierType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_setBiologicalQualifierType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  BiolQualifierType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_setBiologicalQualifierType" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CVTerm_setBiologicalQualifierType" "', argument " "2"" of type '" "BiolQualifierType_t""'");
  } 
  arg2 = static_cast< BiolQualifierType_t >(val2);
  result = (int)(arg1)->setBiologicalQualifierType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_setModelQualifierType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_setModelQualifierType" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CVTerm_setModelQualifierType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CVTerm_setModelQualifierType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setModelQualifierType((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_setModelQualifierType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CVTerm_setModelQualifierType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CVTerm_setModelQualifierType__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CVTerm_setModelQualifierType__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CVTerm_setModelQualifierType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CVTerm::setModelQualifierType(ModelQualifierType_t)\n"
    "    CVTerm::setModelQualifierType(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CVTerm_setBiologicalQualifierType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_setBiologicalQualifierType" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CVTerm_setBiologicalQualifierType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CVTerm_setBiologicalQualifierType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setBiologicalQualifierType((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_setBiologicalQualifierType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CVTerm_setBiologicalQualifierType", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CVTerm_setBiologicalQualifierType__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CVTerm_setBiologicalQualifierType__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CVTerm_setBiologicalQualifierType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CVTerm::setBiologicalQualifierType(BiolQualifierType_t)\n"
    "    CVTerm::setBiologicalQualifierType(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CVTerm_addResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "CVTerm_addResource", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_addResource" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CVTerm_addResource" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CVTerm_addResource" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->addResource((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_removeResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "CVTerm_removeResource", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_removeResource" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CVTerm_removeResource" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->removeResource(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_hasRequiredAttributes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_hasRequiredAttributes" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (bool)(arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_hasBeenModified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_hasBeenModified" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (bool)(arg1)->hasBeenModified();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_resetModifiedFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_resetModifiedFlags" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  (arg1)->resetModifiedFlags();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_hasRequiredAttributes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_hasRequiredAttributes" "', argument " "1"" of type '" "CVTerm const *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (bool)((CVTerm const *)arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_hasRequiredAttributes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CVTerm_hasRequiredAttributes", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_hasRequiredAttributes__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_hasRequiredAttributes__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CVTerm_hasRequiredAttributes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CVTerm::hasRequiredAttributes()\n"
    "    CVTerm::hasRequiredAttributes() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CVTerm_getNumNestedCVTerms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getNumNestedCVTerms" "', argument " "1"" of type '" "CVTerm const *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (unsigned int)((CVTerm const *)arg1)->getNumNestedCVTerms();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getNestedCVTerm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  CVTerm *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getNestedCVTerm" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CVTerm_getNestedCVTerm" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CVTerm *)(arg1)->getNestedCVTerm(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getNestedCVTerm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  CVTerm *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getNestedCVTerm" "', argument " "1"" of type '" "CVTerm const *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CVTerm_getNestedCVTerm" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CVTerm *)((CVTerm const *)arg1)->getNestedCVTerm(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getNestedCVTerm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CVTerm_getNestedCVTerm", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CVTerm_getNestedCVTerm__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CVTerm_getNestedCVTerm__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CVTerm_getNestedCVTerm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CVTerm::getNestedCVTerm(unsigned int)\n"
    "    CVTerm::getNestedCVTerm(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CVTerm_getListNestedCVTerms__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  List *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getListNestedCVTerms" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (List *)(arg1)->getListNestedCVTerms();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_List, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getListNestedCVTerms__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  List *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_getListNestedCVTerms" "', argument " "1"" of type '" "CVTerm const *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  result = (List *)((CVTerm const *)arg1)->getListNestedCVTerms();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_List, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_getListNestedCVTerms(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CVTerm_getListNestedCVTerms", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_getListNestedCVTerms__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CVTerm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CVTerm_getListNestedCVTerms__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CVTerm_getListNestedCVTerms'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CVTerm::getListNestedCVTerms()\n"
    "    CVTerm::getListNestedCVTerms() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CVTerm_addNestedCVTerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  CVTerm *arg2 = (CVTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "CVTerm_addNestedCVTerm", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_addNestedCVTerm" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CVTerm_addNestedCVTerm" "', argument " "2"" of type '" "CVTerm const *""'"); 
  }
  arg2 = reinterpret_cast< CVTerm * >(argp2);
  result = (int)(arg1)->addNestedCVTerm((CVTerm const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CVTerm_removeNestedCVTerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CVTerm *arg1 = (CVTerm *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  CVTerm *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CVTerm_removeNestedCVTerm", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CVTerm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CVTerm_removeNestedCVTerm" "', argument " "1"" of type '" "CVTerm *""'"); 
  }
  arg1 = reinterpret_cast< CVTerm * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CVTerm_removeNestedCVTerm" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (CVTerm *)(arg1)->removeNestedCVTerm(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CVTerm, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CVTerm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CVTerm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CVTerm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ModelQualifierType_toString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelQualifierType_t arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ModelQualifierType_toString" "', argument " "1"" of type '" "ModelQualifierType_t""'");
  } 
  arg1 = static_cast< ModelQualifierType_t >(val1);
  result = (char *)ModelQualifierType_toString(arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BiolQualifierType_toString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  BiolQualifierType_t arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "BiolQualifierType_toString" "', argument " "1"" of type '" "BiolQualifierType_t""'");
  } 
  arg1 = static_cast< BiolQualifierType_t >(val1);
  result = (char *)BiolQualifierType_toString(arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelQualifierType_fromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  ModelQualifierType_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelQualifierType_fromString" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ModelQualifierType_t)ModelQualifierType_fromString((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BiolQualifierType_fromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  BiolQualifierType_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiolQualifierType_fromString" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (BiolQualifierType_t)BiolQualifierType_fromString((char const *)arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int arg8 ;
  unsigned int arg9 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  unsigned int val9 ;
  int ecode9 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Date" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Date" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Date" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Date" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Date" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Date" "', argument " "7"" of type '" "unsigned int""'");
  } 
  arg7 = static_cast< unsigned int >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Date" "', argument " "8"" of type '" "unsigned int""'");
  } 
  arg8 = static_cast< unsigned int >(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Date" "', argument " "9"" of type '" "unsigned int""'");
  } 
  arg9 = static_cast< unsigned int >(val9);
  result = (Date *)new Date(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int arg8 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Date" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Date" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Date" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Date" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Date" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Date" "', argument " "7"" of type '" "unsigned int""'");
  } 
  arg7 = static_cast< unsigned int >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Date" "', argument " "8"" of type '" "unsigned int""'");
  } 
  arg8 = static_cast< unsigned int >(val8);
  result = (Date *)new Date(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Date" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Date" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Date" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Date" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Date" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Date" "', argument " "7"" of type '" "unsigned int""'");
  } 
  arg7 = static_cast< unsigned int >(val7);
  result = (Date *)new Date(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int arg6 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Date" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Date" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Date" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Date" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Date" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  result = (Date *)new Date(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Date" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Date" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Date" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Date" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  result = (Date *)new Date(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Date" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Date" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Date" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  result = (Date *)new Date(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Date" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Date" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (Date *)new Date(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Date" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Date *)new Date(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (Date *)new Date(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Date *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (Date *)new Date();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Date *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Date" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Date" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (Date *)new Date((std::string const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Date" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Date" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Date" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (Date *)new Date((Date const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Date", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Date__SWIG_9(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Date__SWIG_11(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Date__SWIG_8(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Date__SWIG_10(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Date__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Date__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Date__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Date__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Date__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Date__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_Date__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_unsigned_SS_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_Date__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Date'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Date::Date(unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int)\n"
    "    Date::Date(unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int)\n"
    "    Date::Date(unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int)\n"
    "    Date::Date(unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int)\n"
    "    Date::Date(unsigned int,unsigned int,unsigned int,unsigned int,unsigned int)\n"
    "    Date::Date(unsigned int,unsigned int,unsigned int,unsigned int)\n"
    "    Date::Date(unsigned int,unsigned int,unsigned int)\n"
    "    Date::Date(unsigned int,unsigned int)\n"
    "    Date::Date(unsigned int)\n"
    "    Date::Date()\n"
    "    Date::Date(std::string const &)\n"
    "    Date::Date(Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Date_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_clone" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (Date *)((Date const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_getYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_getYear" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (unsigned int)(arg1)->getYear();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_getMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_getMonth" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (unsigned int)(arg1)->getMonth();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_getDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_getDay" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (unsigned int)(arg1)->getDay();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_getHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_getHour" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (unsigned int)(arg1)->getHour();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_getMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_getMinute" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (unsigned int)(arg1)->getMinute();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_getSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_getSecond" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (unsigned int)(arg1)->getSecond();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_getSignOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_getSignOffset" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (unsigned int)(arg1)->getSignOffset();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_getHoursOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_getHoursOffset" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (unsigned int)(arg1)->getHoursOffset();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_getMinutesOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_getMinutesOffset" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (unsigned int)(arg1)->getMinutesOffset();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_getDateAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_getDateAsString" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (std::string *) &(arg1)->getDateAsString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_setYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_setYear", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_setYear" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date_setYear" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->setYear(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_setMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_setMonth", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_setMonth" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date_setMonth" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->setMonth(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_setDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_setDay", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_setDay" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date_setDay" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->setDay(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_setHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_setHour", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_setHour" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date_setHour" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->setHour(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_setMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_setMinute", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_setMinute" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date_setMinute" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->setMinute(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_setSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_setSecond", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_setSecond" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date_setSecond" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->setSecond(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_setSignOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_setSignOffset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_setSignOffset" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date_setSignOffset" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->setSignOffset(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_setHoursOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_setHoursOffset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_setHoursOffset" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date_setHoursOffset" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->setHoursOffset(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_setMinutesOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_setMinutesOffset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_setMinutesOffset" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date_setMinutesOffset" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->setMinutesOffset(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_setDateAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_setDateAsString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_setDateAsString" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Date_setDateAsString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date_setDateAsString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setDateAsString((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_representsValidDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_representsValidDate" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (bool)(arg1)->representsValidDate();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_hasBeenModified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_hasBeenModified" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  result = (bool)(arg1)->hasBeenModified();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_resetModifiedFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_resetModifiedFlags" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  (arg1)->resetModifiedFlags();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Date_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Date, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Date_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ModelCreator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ModelCreator *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ModelCreator *)new ModelCreator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelCreator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModelCreator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  ModelCreator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_XMLNode,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ModelCreator" "', argument " "1"" of type '" "XMLNode const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ModelCreator" "', argument " "1"" of type '" "XMLNode const""'");
    } else {
      XMLNode * temp = reinterpret_cast< XMLNode * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (ModelCreator *)new ModelCreator(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelCreator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ModelCreator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModelCreator" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModelCreator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ModelCreator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ModelCreator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ModelCreator" "', argument " "1"" of type '" "ModelCreator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ModelCreator" "', argument " "1"" of type '" "ModelCreator const &""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (ModelCreator *)new ModelCreator((ModelCreator const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelCreator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModelCreator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ModelCreator", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ModelCreator__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_XMLNode, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ModelCreator__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ModelCreator, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ModelCreator__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ModelCreator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ModelCreator::ModelCreator()\n"
    "    ModelCreator::ModelCreator(XMLNode const)\n"
    "    ModelCreator::ModelCreator(ModelCreator const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelCreator_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ModelCreator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_clone" "', argument " "1"" of type '" "ModelCreator const *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (ModelCreator *)((ModelCreator const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelCreator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_getFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_getFamilyName" "', argument " "1"" of type '" "ModelCreator const *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (std::string *) &((ModelCreator const *)arg1)->getFamilyName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_getGivenName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_getGivenName" "', argument " "1"" of type '" "ModelCreator const *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (std::string *) &((ModelCreator const *)arg1)->getGivenName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_getEmail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_getEmail" "', argument " "1"" of type '" "ModelCreator const *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (std::string *) &((ModelCreator const *)arg1)->getEmail();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_getOrganization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_getOrganization" "', argument " "1"" of type '" "ModelCreator const *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (std::string *) &((ModelCreator const *)arg1)->getOrganization();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_getOrganisation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_getOrganisation" "', argument " "1"" of type '" "ModelCreator const *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (std::string *) &((ModelCreator const *)arg1)->getOrganisation();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_getName" "', argument " "1"" of type '" "ModelCreator const *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (std::string *) &((ModelCreator const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_isSetFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_isSetFamilyName" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (bool)(arg1)->isSetFamilyName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_isSetGivenName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_isSetGivenName" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (bool)(arg1)->isSetGivenName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_isSetEmail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_isSetEmail" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (bool)(arg1)->isSetEmail();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_isSetOrganization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_isSetOrganization" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (bool)(arg1)->isSetOrganization();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_isSetOrganisation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_isSetOrganisation" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (bool)(arg1)->isSetOrganisation();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_isSetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_isSetName" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (bool)(arg1)->isSetName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_setFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelCreator_setFamilyName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_setFamilyName" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCreator_setFamilyName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCreator_setFamilyName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setFamilyName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_setGivenName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelCreator_setGivenName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_setGivenName" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCreator_setGivenName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCreator_setGivenName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setGivenName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_setEmail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelCreator_setEmail", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_setEmail" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCreator_setEmail" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCreator_setEmail" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setEmail((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_setOrganization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelCreator_setOrganization", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_setOrganization" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCreator_setOrganization" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCreator_setOrganization" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setOrganization((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_setOrganisation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelCreator_setOrganisation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_setOrganisation" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCreator_setOrganisation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCreator_setOrganisation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setOrganisation((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelCreator_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_setName" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCreator_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCreator_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setName((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_unsetFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_unsetFamilyName" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (int)(arg1)->unsetFamilyName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_unsetGivenName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_unsetGivenName" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (int)(arg1)->unsetGivenName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_unsetEmail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_unsetEmail" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (int)(arg1)->unsetEmail();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_unsetOrganization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_unsetOrganization" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (int)(arg1)->unsetOrganization();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_unsetOrganisation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_unsetOrganisation" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (int)(arg1)->unsetOrganisation();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_unsetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_unsetName" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (int)(arg1)->unsetName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_hasRequiredAttributes" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (bool)(arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_hasBeenModified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_hasBeenModified" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (bool)(arg1)->hasBeenModified();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_resetModifiedFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_resetModifiedFlags" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  (arg1)->resetModifiedFlags();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_usingFNVcard4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_usingFNVcard4" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (bool)(arg1)->usingFNVcard4();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_usingSingleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_usingSingleName" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  result = (bool)(arg1)->usingSingleName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelCreator_setUseSingleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelCreator *arg1 = (ModelCreator *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelCreator_setUseSingleName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCreator_setUseSingleName" "', argument " "1"" of type '" "ModelCreator *""'"); 
  }
  arg1 = reinterpret_cast< ModelCreator * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModelCreator_setUseSingleName" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseSingleName(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ModelCreator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ModelCreator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ModelCreator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ModelHistory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ModelHistory *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ModelHistory *)new ModelHistory();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelHistory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ModelHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModelHistory" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModelHistory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ModelHistory *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ModelHistory,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ModelHistory" "', argument " "1"" of type '" "ModelHistory const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ModelHistory" "', argument " "1"" of type '" "ModelHistory const &""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  result = (ModelHistory *)new ModelHistory((ModelHistory const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelHistory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModelHistory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ModelHistory", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ModelHistory__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ModelHistory, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ModelHistory__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ModelHistory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ModelHistory::ModelHistory()\n"
    "    ModelHistory::ModelHistory(ModelHistory const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelHistory_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ModelHistory *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_clone" "', argument " "1"" of type '" "ModelHistory const *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  result = (ModelHistory *)((ModelHistory const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelHistory, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_getCreatedDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_getCreatedDate" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  result = (Date *)(arg1)->getCreatedDate();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_getModifiedDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_getModifiedDate" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  result = (Date *)(arg1)->getModifiedDate();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_isSetCreatedDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_isSetCreatedDate" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  result = (bool)(arg1)->isSetCreatedDate();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_isSetModifiedDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_isSetModifiedDate" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  result = (bool)(arg1)->isSetModifiedDate();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_setCreatedDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  Date *arg2 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelHistory_setCreatedDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_setCreatedDate" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelHistory_setCreatedDate" "', argument " "2"" of type '" "Date *""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  result = (int)(arg1)->setCreatedDate(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_setModifiedDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  Date *arg2 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelHistory_setModifiedDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_setModifiedDate" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelHistory_setModifiedDate" "', argument " "2"" of type '" "Date *""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  result = (int)(arg1)->setModifiedDate(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_addModifiedDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  Date *arg2 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelHistory_addModifiedDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_addModifiedDate" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelHistory_addModifiedDate" "', argument " "2"" of type '" "Date *""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  result = (int)(arg1)->addModifiedDate(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_getListModifiedDates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  List *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_getListModifiedDates" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  result = (List *)(arg1)->getListModifiedDates();
  {
    ListWrapper<Date> *listw = (result != 0) ? new ListWrapper<Date>(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(listw),
      
      SWIGTYPE_p_ListWrapperT_Date_t,
      
      
      
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_getModifiedDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_getModifiedDate" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModelHistory_getModifiedDate" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Date *)(arg1)->getModifiedDate(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_getModifiedDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ModelHistory_getModifiedDate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ModelHistory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ModelHistory_getModifiedDate__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ModelHistory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ModelHistory_getModifiedDate__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ModelHistory_getModifiedDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ModelHistory::getModifiedDate()\n"
    "    ModelHistory::getModifiedDate(unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModelHistory_getNumModifiedDates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_getNumModifiedDates" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  result = (unsigned int)(arg1)->getNumModifiedDates();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_addCreator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  ModelCreator *arg2 = (ModelCreator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelHistory_addCreator", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_addCreator" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ModelCreator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelHistory_addCreator" "', argument " "2"" of type '" "ModelCreator *""'"); 
  }
  arg2 = reinterpret_cast< ModelCreator * >(argp2);
  result = (int)(arg1)->addCreator(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_getListCreators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  List *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_getListCreators" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  result = (List *)(arg1)->getListCreators();
  {
    ListWrapper<ModelCreator> *listw = (result != 0) ? new ListWrapper<ModelCreator>(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(listw),
      
      SWIGTYPE_p_ListWrapperT_ModelCreator_t,
      
      
      
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_getCreator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ModelCreator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ModelHistory_getCreator", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_getCreator" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModelHistory_getCreator" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ModelCreator *)(arg1)->getCreator(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelCreator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_getNumCreators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_getNumCreators" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  result = (unsigned int)(arg1)->getNumCreators();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_hasRequiredAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_hasRequiredAttributes" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  result = (bool)(arg1)->hasRequiredAttributes();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_hasBeenModified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_hasBeenModified" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  result = (bool)(arg1)->hasBeenModified();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModelHistory_resetModifiedFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ModelHistory *arg1 = (ModelHistory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelHistory_resetModifiedFlags" "', argument " "1"" of type '" "ModelHistory *""'"); 
  }
  arg1 = reinterpret_cast< ModelHistory * >(argp1);
  (arg1)->resetModifiedFlags();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ModelHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ModelHistory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ModelHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_RDFAnnotationParser_parseRDFAnnotation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  char *arg2 = (char *) 0 ;
  XMLInputStream *arg3 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ModelHistory *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "3"" of type '" "XMLInputStream *""'"); 
  }
  arg3 = reinterpret_cast< XMLInputStream * >(argp3);
  result = (ModelHistory *)RDFAnnotationParser::parseRDFAnnotation((XMLNode const *)arg1,(char const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_parseRDFAnnotation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  ModelHistory *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (ModelHistory *)RDFAnnotationParser::parseRDFAnnotation((XMLNode const *)arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelHistory, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_parseRDFAnnotation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ModelHistory *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  result = (ModelHistory *)RDFAnnotationParser::parseRDFAnnotation((XMLNode const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ModelHistory, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_createAnnotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "RDFAnnotationParser_createAnnotation", 0, 0, 0)) SWIG_fail;
  result = (XMLNode *)RDFAnnotationParser::createAnnotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_createRDFAnnotation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RDFAnnotationParser_createRDFAnnotation" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RDFAnnotationParser_createRDFAnnotation" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (XMLNode *)RDFAnnotationParser::createRDFAnnotation(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_createRDFAnnotation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  XMLNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RDFAnnotationParser_createRDFAnnotation" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (XMLNode *)RDFAnnotationParser::createRDFAnnotation(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_createRDFAnnotation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  XMLNode *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (XMLNode *)RDFAnnotationParser::createRDFAnnotation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_createRDFAnnotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RDFAnnotationParser_createRDFAnnotation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_RDFAnnotationParser_createRDFAnnotation__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_RDFAnnotationParser_createRDFAnnotation__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RDFAnnotationParser_createRDFAnnotation__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RDFAnnotationParser_createRDFAnnotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RDFAnnotationParser::createRDFAnnotation(unsigned int,unsigned int)\n"
    "    RDFAnnotationParser::createRDFAnnotation(unsigned int)\n"
    "    RDFAnnotationParser::createRDFAnnotation()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_createCVTerms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_createCVTerms" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (XMLNode *)RDFAnnotationParser::createCVTerms((SBase const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_parseCVTerms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_parseCVTerms" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (XMLNode *)RDFAnnotationParser::parseCVTerms((SBase const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_parseModelHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_parseModelHistory" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (XMLNode *)RDFAnnotationParser::parseModelHistory((SBase const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_parseOnlyModelHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBase *arg1 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_parseOnlyModelHistory" "', argument " "1"" of type '" "SBase const *""'"); 
  }
  arg1 = reinterpret_cast< SBase * >(argp1);
  result = (XMLNode *)RDFAnnotationParser::parseOnlyModelHistory((SBase const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_deleteRDFAnnotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_deleteRDFAnnotation" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  result = (XMLNode *)RDFAnnotationParser::deleteRDFAnnotation((XMLNode const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_deleteRDFHistoryAnnotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_deleteRDFHistoryAnnotation" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  result = (XMLNode *)RDFAnnotationParser::deleteRDFHistoryAnnotation((XMLNode const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_deleteRDFCVTermAnnotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_deleteRDFCVTermAnnotation" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  result = (XMLNode *)RDFAnnotationParser::deleteRDFCVTermAnnotation((XMLNode const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_parseRDFAnnotation__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  ListWrapper< CVTerm > *arg2 = (ListWrapper< CVTerm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "2"" of type '" "ListWrapper< CVTerm > *""'"); 
  }
  arg2 = reinterpret_cast< ListWrapper< CVTerm > * >(argp2);
  RDFAnnotationParser_parseRDFAnnotation__SWIG_3((XMLNode const *)arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_parseRDFAnnotation__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  ListWrapper< CVTerm > *arg2 = (ListWrapper< CVTerm > *) 0 ;
  char *arg3 = (char *) 0 ;
  XMLInputStream *arg4 = (XMLInputStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "2"" of type '" "ListWrapper< CVTerm > *""'"); 
  }
  arg2 = reinterpret_cast< ListWrapper< CVTerm > * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_XMLInputStream, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "4"" of type '" "XMLInputStream *""'"); 
  }
  arg4 = reinterpret_cast< XMLInputStream * >(argp4);
  RDFAnnotationParser_parseRDFAnnotation__SWIG_4((XMLNode const *)arg1,arg2,(char const *)arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_parseRDFAnnotation__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  XMLNode *arg1 = (XMLNode *) 0 ;
  ListWrapper< CVTerm > *arg2 = (ListWrapper< CVTerm > *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_XMLNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "1"" of type '" "XMLNode const *""'"); 
  }
  arg1 = reinterpret_cast< XMLNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ListWrapperT_CVTerm_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "2"" of type '" "ListWrapper< CVTerm > *""'"); 
  }
  arg2 = reinterpret_cast< ListWrapper< CVTerm > * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RDFAnnotationParser_parseRDFAnnotation" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  RDFAnnotationParser_parseRDFAnnotation__SWIG_4((XMLNode const *)arg1,arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RDFAnnotationParser_parseRDFAnnotation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RDFAnnotationParser_parseRDFAnnotation", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RDFAnnotationParser_parseRDFAnnotation__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ListWrapperT_CVTerm_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RDFAnnotationParser_parseRDFAnnotation__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RDFAnnotationParser_parseRDFAnnotation__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ListWrapperT_CVTerm_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RDFAnnotationParser_parseRDFAnnotation__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_XMLInputStream, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RDFAnnotationParser_parseRDFAnnotation__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XMLNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ListWrapperT_CVTerm_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_XMLInputStream, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RDFAnnotationParser_parseRDFAnnotation__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RDFAnnotationParser_parseRDFAnnotation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RDFAnnotationParser::parseRDFAnnotation(XMLNode const *,char const *,XMLInputStream *)\n"
    "    RDFAnnotationParser::parseRDFAnnotation(XMLNode const *,char const *)\n"
    "    RDFAnnotationParser::parseRDFAnnotation(XMLNode const *)\n"
    "    RDFAnnotationParser::parseRDFAnnotation(XMLNode const *,ListWrapper< CVTerm > *)\n"
    "    RDFAnnotationParser::parseRDFAnnotation(XMLNode const *,ListWrapper< CVTerm > *,char const *,XMLInputStream *)\n"
    "    RDFAnnotationParser::RDFAnnotationParser_parseRDFAnnotation__SWIG_4(XMLNode const *,ListWrapper< CVTerm > *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_RDFAnnotationParser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  RDFAnnotationParser *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_RDFAnnotationParser", 0, 0, 0)) SWIG_fail;
  result = (RDFAnnotationParser *)new RDFAnnotationParser();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RDFAnnotationParser, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RDFAnnotationParser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  RDFAnnotationParser *arg1 = (RDFAnnotationParser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RDFAnnotationParser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RDFAnnotationParser" "', argument " "1"" of type '" "RDFAnnotationParser *""'"); 
  }
  arg1 = reinterpret_cast< RDFAnnotationParser * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RDFAnnotationParser_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RDFAnnotationParser, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RDFAnnotationParser_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_ISBMLExtensionNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ISBMLExtensionNamespaces *arg1 = (ISBMLExtensionNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ISBMLExtensionNamespaces, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ISBMLExtensionNamespaces" "', argument " "1"" of type '" "ISBMLExtensionNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< ISBMLExtensionNamespaces * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ISBMLExtensionNamespaces_getURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ISBMLExtensionNamespaces *arg1 = (ISBMLExtensionNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ISBMLExtensionNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ISBMLExtensionNamespaces_getURI" "', argument " "1"" of type '" "ISBMLExtensionNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< ISBMLExtensionNamespaces * >(argp1);
  result = ((ISBMLExtensionNamespaces const *)arg1)->getURI();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ISBMLExtensionNamespaces_getPackageVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ISBMLExtensionNamespaces *arg1 = (ISBMLExtensionNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ISBMLExtensionNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ISBMLExtensionNamespaces_getPackageVersion" "', argument " "1"" of type '" "ISBMLExtensionNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< ISBMLExtensionNamespaces * >(argp1);
  result = (unsigned int)((ISBMLExtensionNamespaces const *)arg1)->getPackageVersion();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ISBMLExtensionNamespaces_getPackageName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ISBMLExtensionNamespaces *arg1 = (ISBMLExtensionNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ISBMLExtensionNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ISBMLExtensionNamespaces_getPackageName" "', argument " "1"" of type '" "ISBMLExtensionNamespaces const *""'"); 
  }
  arg1 = reinterpret_cast< ISBMLExtensionNamespaces * >(argp1);
  result = (std::string *) &((ISBMLExtensionNamespaces const *)arg1)->getPackageName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ISBMLExtensionNamespaces_setPackageVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ISBMLExtensionNamespaces *arg1 = (ISBMLExtensionNamespaces *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ISBMLExtensionNamespaces_setPackageVersion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ISBMLExtensionNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ISBMLExtensionNamespaces_setPackageVersion" "', argument " "1"" of type '" "ISBMLExtensionNamespaces *""'"); 
  }
  arg1 = reinterpret_cast< ISBMLExtensionNamespaces * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ISBMLExtensionNamespaces_setPackageVersion" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setPackageVersion(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ISBMLExtensionNamespaces_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ISBMLExtensionNamespaces, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SBaseExtensionPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int arg2 ;
  int res1 = SWIG_OLDOBJ ;
  int val2 ;
  int ecode2 = 0 ;
  SBaseExtensionPoint *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBaseExtensionPoint" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBaseExtensionPoint" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBaseExtensionPoint" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SBaseExtensionPoint *)new SBaseExtensionPoint((std::string const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBaseExtensionPoint, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBaseExtensionPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  SBaseExtensionPoint *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBaseExtensionPoint" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBaseExtensionPoint" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBaseExtensionPoint" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SBaseExtensionPoint" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBaseExtensionPoint" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SBaseExtensionPoint" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (SBaseExtensionPoint *)new SBaseExtensionPoint((std::string const &)*arg1,arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBaseExtensionPoint, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBaseExtensionPoint__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  SBaseExtensionPoint *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBaseExtensionPoint" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBaseExtensionPoint" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBaseExtensionPoint" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SBaseExtensionPoint" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBaseExtensionPoint" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (SBaseExtensionPoint *)new SBaseExtensionPoint((std::string const &)*arg1,arg2,(std::string const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBaseExtensionPoint, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBaseExtensionPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBaseExtensionPoint *arg1 = (SBaseExtensionPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBaseExtensionPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBaseExtensionPoint" "', argument " "1"" of type '" "SBaseExtensionPoint *""'"); 
  }
  arg1 = reinterpret_cast< SBaseExtensionPoint * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBaseExtensionPoint__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBaseExtensionPoint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBaseExtensionPoint *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBaseExtensionPoint,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBaseExtensionPoint" "', argument " "1"" of type '" "SBaseExtensionPoint const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBaseExtensionPoint" "', argument " "1"" of type '" "SBaseExtensionPoint const &""'"); 
  }
  arg1 = reinterpret_cast< SBaseExtensionPoint * >(argp1);
  result = (SBaseExtensionPoint *)new SBaseExtensionPoint((SBaseExtensionPoint const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBaseExtensionPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBaseExtensionPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBaseExtensionPoint", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBaseExtensionPoint, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBaseExtensionPoint__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SBaseExtensionPoint__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SBaseExtensionPoint__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[2], (std::basic_string<char>**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SBaseExtensionPoint__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBaseExtensionPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBaseExtensionPoint::SBaseExtensionPoint(std::string const &,int)\n"
    "    SBaseExtensionPoint::SBaseExtensionPoint(std::string const &,int,std::string const &,bool)\n"
    "    SBaseExtensionPoint::SBaseExtensionPoint(std::string const &,int,std::string const &)\n"
    "    SBaseExtensionPoint::SBaseExtensionPoint(SBaseExtensionPoint const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBaseExtensionPoint_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBaseExtensionPoint *arg1 = (SBaseExtensionPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBaseExtensionPoint *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBaseExtensionPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBaseExtensionPoint_clone" "', argument " "1"" of type '" "SBaseExtensionPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SBaseExtensionPoint * >(argp1);
  result = (SBaseExtensionPoint *)((SBaseExtensionPoint const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBaseExtensionPoint, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBaseExtensionPoint_getPackageName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBaseExtensionPoint *arg1 = (SBaseExtensionPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBaseExtensionPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBaseExtensionPoint_getPackageName" "', argument " "1"" of type '" "SBaseExtensionPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SBaseExtensionPoint * >(argp1);
  result = (std::string *) &((SBaseExtensionPoint const *)arg1)->getPackageName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBaseExtensionPoint_getTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBaseExtensionPoint *arg1 = (SBaseExtensionPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBaseExtensionPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBaseExtensionPoint_getTypeCode" "', argument " "1"" of type '" "SBaseExtensionPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SBaseExtensionPoint * >(argp1);
  result = (int)((SBaseExtensionPoint const *)arg1)->getTypeCode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBaseExtensionPoint_getElementName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBaseExtensionPoint *arg1 = (SBaseExtensionPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBaseExtensionPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBaseExtensionPoint_getElementName" "', argument " "1"" of type '" "SBaseExtensionPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SBaseExtensionPoint * >(argp1);
  result = (std::string *) &((SBaseExtensionPoint const *)arg1)->getElementName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBaseExtensionPoint_isElementOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBaseExtensionPoint *arg1 = (SBaseExtensionPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBaseExtensionPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBaseExtensionPoint_isElementOnly" "', argument " "1"" of type '" "SBaseExtensionPoint const *""'"); 
  }
  arg1 = reinterpret_cast< SBaseExtensionPoint * >(argp1);
  result = (bool)((SBaseExtensionPoint const *)arg1)->isElementOnly();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBaseExtensionPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBaseExtensionPoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBaseExtensionPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SBasePlugin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBasePlugin" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getElementNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getElementNamespace" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (std::string *) &((SBasePlugin const *)arg1)->getElementNamespace();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getPrefix" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (std::string *) &((SBasePlugin const *)arg1)->getPrefix();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getPackageName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getPackageName" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (std::string *) &((SBasePlugin const *)arg1)->getPackageName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBasePlugin *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_clone" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (SBasePlugin *)((SBasePlugin const *)arg1)->clone();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getElementBySId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_getElementBySId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getElementBySId" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_getElementBySId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementBySId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getElementByMetaId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBase *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_getElementByMetaId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getElementByMetaId" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_getElementByMetaId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBase *)(arg1)->getElementByMetaId((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_connectToParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_connectToParent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_connectToParent" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_connectToParent" "', argument " "2"" of type '" "SBase *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  (arg1)->connectToParent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_enablePackageInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_enablePackageInternal", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_enablePackageInternal" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBasePlugin_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBasePlugin_enablePackageInternal" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->enablePackageInternal((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_stripPackage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_stripPackage", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_stripPackage" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_stripPackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_stripPackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBasePlugin_stripPackage" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->stripPackage((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getSBMLDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getSBMLDocument" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (SBMLDocument *)(arg1)->getSBMLDocument();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getSBMLDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLDocument *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getSBMLDocument" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (SBMLDocument *)((SBasePlugin const *)arg1)->getSBMLDocument();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocument, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getSBMLDocument(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBasePlugin_getSBMLDocument", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBasePlugin_getSBMLDocument__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBasePlugin_getSBMLDocument__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBasePlugin_getSBMLDocument'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBasePlugin::getSBMLDocument()\n"
    "    SBasePlugin::getSBMLDocument() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getURI" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = ((SBasePlugin const *)arg1)->getURI();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getParentSBMLObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBase *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getParentSBMLObject" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (SBase *)(arg1)->getParentSBMLObject();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getParentSBMLObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBase *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getParentSBMLObject" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (SBase *)((SBasePlugin const *)arg1)->getParentSBMLObject();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getParentSBMLObject(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBasePlugin_getParentSBMLObject", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBasePlugin_getParentSBMLObject__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBasePlugin_getParentSBMLObject__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBasePlugin_getParentSBMLObject'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBasePlugin::getParentSBMLObject()\n"
    "    SBasePlugin::getParentSBMLObject() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_setElementNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_setElementNamespace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_setElementNamespace" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_setElementNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_setElementNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setElementNamespace((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getLevel" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (unsigned int)((SBasePlugin const *)arg1)->getLevel();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getVersion" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (unsigned int)((SBasePlugin const *)arg1)->getVersion();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getPackageVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getPackageVersion" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (unsigned int)((SBasePlugin const *)arg1)->getPackageVersion();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_replaceSIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_replaceSIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_replaceSIDWithFunction" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_replaceSIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBasePlugin_replaceSIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceSIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_divideAssignmentsToSIdByFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_divideAssignmentsToSIdByFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_divideAssignmentsToSIdByFunction" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_divideAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_divideAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBasePlugin_divideAssignmentsToSIdByFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->divideAssignmentsToSIdByFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_multiplyAssignmentsToSIdByFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_multiplyAssignmentsToSIdByFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_multiplyAssignmentsToSIdByFunction" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_multiplyAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_multiplyAssignmentsToSIdByFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBasePlugin_multiplyAssignmentsToSIdByFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->multiplyAssignmentsToSIdByFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_hasIdentifierBeginningWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_hasIdentifierBeginningWith", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_hasIdentifierBeginningWith" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_hasIdentifierBeginningWith" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_hasIdentifierBeginningWith" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->hasIdentifierBeginningWith((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_prependStringToAllIdentifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_prependStringToAllIdentifiers", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_prependStringToAllIdentifiers" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_prependStringToAllIdentifiers" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_prependStringToAllIdentifiers" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->prependStringToAllIdentifiers((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_renameSIdRefs" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBasePlugin_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_renameMetaIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_renameMetaIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_renameMetaIdRefs" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_renameMetaIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_renameMetaIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBasePlugin_renameMetaIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_renameMetaIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameMetaIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_renameUnitSIdRefs" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBasePlugin_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_transformIdentifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  IdentifierTransformer *arg2 = (IdentifierTransformer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_transformIdentifiers", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_transformIdentifiers" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_IdentifierTransformer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_transformIdentifiers" "', argument " "2"" of type '" "IdentifierTransformer *""'"); 
  }
  arg2 = reinterpret_cast< IdentifierTransformer * >(argp2);
  result = (int)(arg1)->transformIdentifiers(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getLine" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (unsigned int)((SBasePlugin const *)arg1)->getLine();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getColumn" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (unsigned int)((SBasePlugin const *)arg1)->getColumn();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getSBMLNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLNamespaces *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getSBMLNamespaces" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (SBMLNamespaces *)((SBasePlugin const *)arg1)->getSBMLNamespaces();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_logUnknownElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_logUnknownElement", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_logUnknownElement" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_logUnknownElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_logUnknownElement" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBasePlugin_logUnknownElement" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBasePlugin_logUnknownElement" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBasePlugin_logUnknownElement" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  (arg1)->logUnknownElement((std::string const &)*arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_isValidTypeForList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_isValidTypeForList", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_isValidTypeForList" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_isValidTypeForList" "', argument " "2"" of type '" "SBase *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  result = (bool)((SBasePlugin const *)arg1)->isValidTypeForList(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getSBMLExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLExtension *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getSBMLExtension" "', argument " "1"" of type '" "SBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = (SBMLExtension *)((SBasePlugin const *)arg1)->getSBMLExtension();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_updateSBMLNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBasePlugin_updateSBMLNamespace", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_updateSBMLNamespace" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBasePlugin_updateSBMLNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBasePlugin_updateSBMLNamespace" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBasePlugin_updateSBMLNamespace" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  (arg1)->updateSBMLNamespace((std::string const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getListOfAllElements__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  ElementFilter *arg2 = (ElementFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ListWrapper< SBase > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getListOfAllElements" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ElementFilter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBasePlugin_getListOfAllElements" "', argument " "2"" of type '" "ElementFilter *""'"); 
  }
  arg2 = reinterpret_cast< ElementFilter * >(argp2);
  result = SBasePlugin_getListOfAllElements__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new ListWrapper< SBase >(static_cast< const ListWrapper< SBase >& >(result))), SWIGTYPE_p_ListWrapperT_SBase_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getListOfAllElements__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBasePlugin *arg1 = (SBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ListWrapper< SBase > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBasePlugin_getListOfAllElements" "', argument " "1"" of type '" "SBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBasePlugin * >(argp1);
  result = SBasePlugin_getListOfAllElements__SWIG_0(arg1);
  resultobj = SWIG_NewPointerObj((new ListWrapper< SBase >(static_cast< const ListWrapper< SBase >& >(result))), SWIGTYPE_p_ListWrapperT_SBase_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBasePlugin_getListOfAllElements(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SBasePlugin_getListOfAllElements", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SBasePlugin_getListOfAllElements__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ElementFilter, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SBasePlugin_getListOfAllElements__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SBasePlugin_getListOfAllElements'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBasePlugin::getListOfAllElements(ElementFilter *)\n"
    "    SBasePlugin::getListOfAllElements()\n");
  return 0;
}


SWIGINTERN PyObject *SBasePlugin_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBasePlugin, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SBMLDocumentPlugin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  SBMLNamespaces *arg3 = (SBMLNamespaces *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SBMLDocumentPlugin *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLDocumentPlugin" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLDocumentPlugin" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBMLDocumentPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLDocumentPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SBMLDocumentPlugin" "', argument " "3"" of type '" "SBMLNamespaces *""'"); 
  }
  arg3 = reinterpret_cast< SBMLNamespaces * >(argp3);
  result = (SBMLDocumentPlugin *)new SBMLDocumentPlugin((std::string const &)*arg1,(std::string const &)*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocumentPlugin, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLDocumentPlugin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SBMLDocumentPlugin *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SBMLDocumentPlugin *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SBMLDocumentPlugin,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLDocumentPlugin" "', argument " "1"" of type '" "SBMLDocumentPlugin const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLDocumentPlugin" "', argument " "1"" of type '" "SBMLDocumentPlugin const &""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocumentPlugin * >(argp1);
  result = (SBMLDocumentPlugin *)new SBMLDocumentPlugin((SBMLDocumentPlugin const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocumentPlugin, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SBMLDocumentPlugin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SBMLDocumentPlugin", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SBMLDocumentPlugin, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SBMLDocumentPlugin__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[0], (std::basic_string<char>**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SBMLDocumentPlugin__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SBMLDocumentPlugin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SBMLDocumentPlugin::SBMLDocumentPlugin(std::string const &,std::string const &,SBMLNamespaces *)\n"
    "    SBMLDocumentPlugin::SBMLDocumentPlugin(SBMLDocumentPlugin const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SBMLDocumentPlugin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocumentPlugin *arg1 = (SBMLDocumentPlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocumentPlugin, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLDocumentPlugin" "', argument " "1"" of type '" "SBMLDocumentPlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocumentPlugin * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocumentPlugin_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocumentPlugin *arg1 = (SBMLDocumentPlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLDocumentPlugin *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocumentPlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocumentPlugin_clone" "', argument " "1"" of type '" "SBMLDocumentPlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocumentPlugin * >(argp1);
  result = (SBMLDocumentPlugin *)((SBMLDocumentPlugin const *)arg1)->clone();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLDocumentPlugin, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocumentPlugin_setRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocumentPlugin *arg1 = (SBMLDocumentPlugin *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLDocumentPlugin_setRequired", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocumentPlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocumentPlugin_setRequired" "', argument " "1"" of type '" "SBMLDocumentPlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocumentPlugin * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLDocumentPlugin_setRequired" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)(arg1)->setRequired(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocumentPlugin_getRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocumentPlugin *arg1 = (SBMLDocumentPlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocumentPlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocumentPlugin_getRequired" "', argument " "1"" of type '" "SBMLDocumentPlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocumentPlugin * >(argp1);
  result = (bool)((SBMLDocumentPlugin const *)arg1)->getRequired();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocumentPlugin_isSetRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocumentPlugin *arg1 = (SBMLDocumentPlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocumentPlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocumentPlugin_isSetRequired" "', argument " "1"" of type '" "SBMLDocumentPlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocumentPlugin * >(argp1);
  result = (bool)((SBMLDocumentPlugin const *)arg1)->isSetRequired();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocumentPlugin_unsetRequired(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocumentPlugin *arg1 = (SBMLDocumentPlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocumentPlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocumentPlugin_unsetRequired" "', argument " "1"" of type '" "SBMLDocumentPlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocumentPlugin * >(argp1);
  result = (int)(arg1)->unsetRequired();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocumentPlugin_isCompFlatteningImplemented(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocumentPlugin *arg1 = (SBMLDocumentPlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocumentPlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocumentPlugin_isCompFlatteningImplemented" "', argument " "1"" of type '" "SBMLDocumentPlugin const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocumentPlugin * >(argp1);
  result = (bool)((SBMLDocumentPlugin const *)arg1)->isCompFlatteningImplemented();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLDocumentPlugin_checkConsistency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocumentPlugin *arg1 = (SBMLDocumentPlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocumentPlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLDocumentPlugin_checkConsistency" "', argument " "1"" of type '" "SBMLDocumentPlugin *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocumentPlugin * >(argp1);
  result = (unsigned int)(arg1)->checkConsistency();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLDocumentPlugin_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLDocumentPlugin, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLDocumentPlugin_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SBMLExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLExtension" "', argument " "1"" of type '" "SBMLExtension *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getNumOfSBasePlugins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getNumOfSBasePlugins" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  result = (int)((SBMLExtension const *)arg1)->getNumOfSBasePlugins();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getNumOfSupportedPackageURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getNumOfSupportedPackageURI" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  result = (unsigned int)((SBMLExtension const *)arg1)->getNumOfSupportedPackageURI();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_isSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_isSupported", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_isSupported" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtension_isSupported" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtension_isSupported" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((SBMLExtension const *)arg1)->isSupported((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getSupportedPackageURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_getSupportedPackageURI", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getSupportedPackageURI" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLExtension_getSupportedPackageURI" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (std::string *) &((SBMLExtension const *)arg1)->getSupportedPackageURI(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLExtension *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_clone" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  result = (SBMLExtension *)((SBMLExtension const *)arg1)->clone();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getName" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  result = (std::string *) &((SBMLExtension const *)arg1)->getName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  std::string *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_getURI", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getURI" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLExtension_getURI" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLExtension_getURI" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBMLExtension_getURI" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  result = (std::string *) &((SBMLExtension const *)arg1)->getURI(arg2,arg3,arg4);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_getLevel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getLevel" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtension_getLevel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtension_getLevel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (unsigned int)((SBMLExtension const *)arg1)->getLevel((std::string const &)*arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_getVersion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getVersion" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtension_getVersion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtension_getVersion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (unsigned int)((SBMLExtension const *)arg1)->getVersion((std::string const &)*arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getPackageVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_getPackageVersion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getPackageVersion" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtension_getPackageVersion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtension_getPackageVersion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (unsigned int)((SBMLExtension const *)arg1)->getPackageVersion((std::string const &)*arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getStringFromTypeCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_getStringFromTypeCode", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getStringFromTypeCode" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLExtension_getStringFromTypeCode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)((SBMLExtension const *)arg1)->getStringFromTypeCode(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getSBMLExtensionNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBMLNamespaces *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_getSBMLExtensionNamespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getSBMLExtensionNamespaces" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtension_getSBMLExtensionNamespaces" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtension_getSBMLExtensionNamespaces" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBMLNamespaces *)((SBMLExtension const *)arg1)->getSBMLExtensionNamespaces((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_setEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_setEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_setEnabled" "', argument " "1"" of type '" "SBMLExtension *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLExtension_setEnabled" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->setEnabled(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_isEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_isEnabled" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  result = (bool)((SBMLExtension const *)arg1)->isEnabled();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_removeL2Namespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  XMLNamespaces *arg2 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_removeL2Namespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_removeL2Namespaces" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtension_removeL2Namespaces" "', argument " "2"" of type '" "XMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< XMLNamespaces * >(argp2);
  ((SBMLExtension const *)arg1)->removeL2Namespaces(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_addL2Namespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  XMLNamespaces *arg2 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_addL2Namespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_addL2Namespaces" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtension_addL2Namespaces" "', argument " "2"" of type '" "XMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< XMLNamespaces * >(argp2);
  ((SBMLExtension const *)arg1)->addL2Namespaces(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_enableL2NamespaceForDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_enableL2NamespaceForDocument", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_enableL2NamespaceForDocument" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtension_enableL2NamespaceForDocument" "', argument " "2"" of type '" "SBMLDocument *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  ((SBMLExtension const *)arg1)->enableL2NamespaceForDocument(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_isInUse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_isInUse", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_isInUse" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtension_isInUse" "', argument " "2"" of type '" "SBMLDocument *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  result = (bool)((SBMLExtension const *)arg1)->isInUse(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_hasMutiplePackageVersions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_hasMutiplePackageVersions" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  result = (bool)((SBMLExtension const *)arg1)->hasMutiplePackageVersions();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getErrorTableIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_getErrorTableIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getErrorTableIndex" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLExtension_getErrorTableIndex" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (unsigned int)((SBMLExtension const *)arg1)->getErrorTableIndex(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getErrorIdOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getErrorIdOffset" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  result = (unsigned int)((SBMLExtension const *)arg1)->getErrorIdOffset();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getSeverity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_getSeverity", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getSeverity" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLExtension_getSeverity" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLExtension_getSeverity" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (unsigned int)((SBMLExtension const *)arg1)->getSeverity(arg2,arg3);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getCategory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_getCategory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getCategory" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLExtension_getCategory" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (unsigned int)((SBMLExtension const *)arg1)->getCategory(arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject *swig_obj[4] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_getMessage", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getMessage" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLExtension_getMessage" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLExtension_getMessage" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res4 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SBMLExtension_getMessage" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtension_getMessage" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  result = ((SBMLExtension const *)arg1)->getMessage(arg2,arg3,(std::string const &)*arg4);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtension_getShortMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtension *arg1 = (SBMLExtension *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtension_getShortMessage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtension_getShortMessage" "', argument " "1"" of type '" "SBMLExtension const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtension * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLExtension_getShortMessage" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = ((SBMLExtension const *)arg1)->getShortMessage(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLExtension_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLExtension, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SBMLExtensionException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  SBMLExtensionException *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBMLExtensionException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBMLExtensionException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (SBMLExtensionException *)new SBMLExtensionException((std::string const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLExtensionException, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SBMLExtensionException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionException *arg1 = (SBMLExtensionException *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionException, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBMLExtensionException" "', argument " "1"" of type '" "SBMLExtensionException *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionException * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLExtensionException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLExtensionException, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SBMLExtensionException_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_getInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_getInstance", 0, 0, 0)) SWIG_fail;
  result = (SBMLExtensionRegistry *) &SBMLExtensionRegistry::getInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_addExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  SBMLExtension *arg2 = (SBMLExtension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_addExtension", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_addExtension" "', argument " "1"" of type '" "SBMLExtensionRegistry *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtensionRegistry_addExtension" "', argument " "2"" of type '" "SBMLExtension const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLExtension * >(argp2);
  result = (int)(arg1)->addExtension((SBMLExtension const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_getExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  SBMLExtension *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_getExtension", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_getExtension" "', argument " "1"" of type '" "SBMLExtensionRegistry *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtensionRegistry_getExtension" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtensionRegistry_getExtension" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (SBMLExtension *)(arg1)->getExtension((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_removeL2Namespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  XMLNamespaces *arg2 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_removeL2Namespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_removeL2Namespaces" "', argument " "1"" of type '" "SBMLExtensionRegistry const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtensionRegistry_removeL2Namespaces" "', argument " "2"" of type '" "XMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< XMLNamespaces * >(argp2);
  ((SBMLExtensionRegistry const *)arg1)->removeL2Namespaces(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_addL2Namespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  XMLNamespaces *arg2 = (XMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_addL2Namespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_addL2Namespaces" "', argument " "1"" of type '" "SBMLExtensionRegistry const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtensionRegistry_addL2Namespaces" "', argument " "2"" of type '" "XMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< XMLNamespaces * >(argp2);
  ((SBMLExtensionRegistry const *)arg1)->addL2Namespaces(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_enableL2NamespaceForDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_enableL2NamespaceForDocument", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_enableL2NamespaceForDocument" "', argument " "1"" of type '" "SBMLExtensionRegistry const *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtensionRegistry_enableL2NamespaceForDocument" "', argument " "2"" of type '" "SBMLDocument *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  ((SBMLExtensionRegistry const *)arg1)->enableL2NamespaceForDocument(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_disableUnusedPackages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_disableUnusedPackages", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_disableUnusedPackages" "', argument " "1"" of type '" "SBMLExtensionRegistry *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtensionRegistry_disableUnusedPackages" "', argument " "2"" of type '" "SBMLDocument *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  (arg1)->disableUnusedPackages(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_disablePackage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_disablePackage" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtensionRegistry_disablePackage" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  SBMLExtensionRegistry::disablePackage((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_isPackageEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_isPackageEnabled" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtensionRegistry_isPackageEnabled" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (bool)SBMLExtensionRegistry::isPackageEnabled((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_enablePackage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_enablePackage" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtensionRegistry_enablePackage" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  SBMLExtensionRegistry::enablePackage((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_getNumExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  SBaseExtensionPoint *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_getNumExtension", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_getNumExtension" "', argument " "1"" of type '" "SBMLExtensionRegistry *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SBaseExtensionPoint,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtensionRegistry_getNumExtension" "', argument " "2"" of type '" "SBaseExtensionPoint const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtensionRegistry_getNumExtension" "', argument " "2"" of type '" "SBaseExtensionPoint const &""'"); 
  }
  arg2 = reinterpret_cast< SBaseExtensionPoint * >(argp2);
  result = (unsigned int)(arg1)->getNumExtension((SBaseExtensionPoint const &)*arg2);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_setEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_setEnabled", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_setEnabled" "', argument " "1"" of type '" "SBMLExtensionRegistry *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtensionRegistry_setEnabled" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtensionRegistry_setEnabled" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBMLExtensionRegistry_setEnabled" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->setEnabled((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_isEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_isEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_isEnabled" "', argument " "1"" of type '" "SBMLExtensionRegistry *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtensionRegistry_isEnabled" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtensionRegistry_isEnabled" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->isEnabled((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_isRegistered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_isRegistered", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_isRegistered" "', argument " "1"" of type '" "SBMLExtensionRegistry *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBMLExtensionRegistry_isRegistered" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBMLExtensionRegistry_isRegistered" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->isRegistered((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_getAllRegisteredPackageNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_getAllRegisteredPackageNames", 0, 0, 0)) SWIG_fail;
  result = SBMLExtensionRegistry::getAllRegisteredPackageNames();
  resultobj = SWIG_NewPointerObj((new std::vector< std::string >(static_cast< const std::vector< std::string >& >(result))), SWIGTYPE_p_std__vectorT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_getNumRegisteredPackages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_getNumRegisteredPackages", 0, 0, 0)) SWIG_fail;
  result = (unsigned int)SBMLExtensionRegistry::getNumRegisteredPackages();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_getRegisteredPackageName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SBMLExtensionRegistry_getRegisteredPackageName" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = SBMLExtensionRegistry::getRegisteredPackageName(arg1);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_getASTPlugins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< ASTBasePlugin * > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_getASTPlugins" "', argument " "1"" of type '" "SBMLExtensionRegistry *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  result = (arg1)->getASTPlugins();
  resultobj = SWIG_NewPointerObj((new std::vector< ASTBasePlugin * >(static_cast< const std::vector< ASTBasePlugin * >& >(result))), SWIGTYPE_p_std__vectorT_ASTBasePlugin_p_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_getNumASTPlugins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_getNumASTPlugins" "', argument " "1"" of type '" "SBMLExtensionRegistry *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  result = (unsigned int)(arg1)->getNumASTPlugins();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBMLExtensionRegistry_getASTPlugin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLExtensionRegistry *arg1 = (SBMLExtensionRegistry *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ASTBasePlugin *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SBMLExtensionRegistry_getASTPlugin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLExtensionRegistry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBMLExtensionRegistry_getASTPlugin" "', argument " "1"" of type '" "SBMLExtensionRegistry *""'"); 
  }
  arg1 = reinterpret_cast< SBMLExtensionRegistry * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBMLExtensionRegistry_getASTPlugin" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ASTBasePlugin *)(arg1)->getASTPlugin(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SBMLExtensionRegistry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SBMLExtensionRegistry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Callback *arg1 = (Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Callback, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Callback" "', argument " "1"" of type '" "Callback *""'"); 
  }
  arg1 = reinterpret_cast< Callback * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callback_process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Callback *arg1 = (Callback *) 0 ;
  SBMLDocument *arg2 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Callback_process", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callback_process" "', argument " "1"" of type '" "Callback *""'"); 
  }
  arg1 = reinterpret_cast< Callback * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Callback_process" "', argument " "2"" of type '" "SBMLDocument *""'"); 
  }
  arg2 = reinterpret_cast< SBMLDocument * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (int)(arg1)->Callback::process(arg2);
    } else {
      result = (int)(arg1)->process(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Callback *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Callback *)new SwigDirector_Callback(arg1); 
  } else {
    result = (Callback *)new Callback(); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Callback, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Callback *arg1 = (Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Callback" "', argument " "1"" of type '" "Callback *""'"); 
  }
  arg1 = reinterpret_cast< Callback * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Callback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Callback, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Callback_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CallbackRegistry_invokeCallbacks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SBMLDocument *arg1 = (SBMLDocument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SBMLDocument, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallbackRegistry_invokeCallbacks" "', argument " "1"" of type '" "SBMLDocument *""'"); 
  }
  arg1 = reinterpret_cast< SBMLDocument * >(argp1);
  result = (int)CallbackRegistry::invokeCallbacks(arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallbackRegistry_clearCallbacks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "CallbackRegistry_clearCallbacks", 0, 0, 0)) SWIG_fail;
  CallbackRegistry::clearCallbacks();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallbackRegistry_addCallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Callback *arg1 = (Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallbackRegistry_addCallback" "', argument " "1"" of type '" "Callback *""'"); 
  }
  arg1 = reinterpret_cast< Callback * >(argp1);
  CallbackRegistry::addCallback(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallbackRegistry_getNumCallbacks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "CallbackRegistry_getNumCallbacks", 0, 0, 0)) SWIG_fail;
  result = (int)CallbackRegistry::getNumCallbacks();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallbackRegistry_removeCallback__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CallbackRegistry_removeCallback" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  CallbackRegistry::removeCallback(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallbackRegistry_removeCallback__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Callback *arg1 = (Callback *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Callback, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallbackRegistry_removeCallback" "', argument " "1"" of type '" "Callback *""'"); 
  }
  arg1 = reinterpret_cast< Callback * >(argp1);
  CallbackRegistry::removeCallback(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallbackRegistry_removeCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CallbackRegistry_removeCallback", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Callback, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CallbackRegistry_removeCallback__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_CallbackRegistry_removeCallback__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CallbackRegistry_removeCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CallbackRegistry::removeCallback(int)\n"
    "    CallbackRegistry::removeCallback(Callback *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CallbackRegistry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  CallbackRegistry *arg1 = (CallbackRegistry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CallbackRegistry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CallbackRegistry" "', argument " "1"" of type '" "CallbackRegistry *""'"); 
  }
  arg1 = reinterpret_cast< CallbackRegistry * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CallbackRegistry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CallbackRegistry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ASTNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNodeType_t arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  ASTNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ASTNode" "', argument " "1"" of type '" "ASTNodeType_t""'");
  } 
  arg1 = static_cast< ASTNodeType_t >(val1);
  result = (ASTNode *)new ASTNode(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ASTNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ASTNode *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (ASTNode *)new ASTNode();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ASTNode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ASTNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ASTNode,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ASTNode" "', argument " "1"" of type '" "ASTNode const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ASTNode" "', argument " "1"" of type '" "ASTNode const &""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (ASTNode *)new ASTNode((ASTNode const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ASTNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ASTNode", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ASTNode__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ASTNode, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ASTNode__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ASTNode__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ASTNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASTNode::ASTNode(ASTNodeType_t)\n"
    "    ASTNode::ASTNode()\n"
    "    ASTNode::ASTNode(ASTNode const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ASTNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ASTNode" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_freeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_freeName" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (int)(arg1)->freeName();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_canonicalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_canonicalize" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)(arg1)->canonicalize();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_addChild__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_addChild" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_ASTNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_addChild" "', argument " "2"" of type '" "ASTNode *""'");
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ASTNode_addChild" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (int)(arg1)->addChild(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_addChild__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_addChild" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_ASTNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_addChild" "', argument " "2"" of type '" "ASTNode *""'");
  }
  result = (int)(arg1)->addChild(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_addChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASTNode_addChild", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ASTNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTNode_addChild__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ASTNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ASTNode_addChild__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASTNode_addChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASTNode::addChild(ASTNode *,bool)\n"
    "    ASTNode::addChild(ASTNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASTNode_prependChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_prependChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_prependChild" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_ASTNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_prependChild" "', argument " "2"" of type '" "ASTNode *""'");
  }
  result = (int)(arg1)->prependChild(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_removeChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_removeChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_removeChild" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_removeChild" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (int)(arg1)->removeChild(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_replaceChild__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_replaceChild" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_replaceChild" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_ASTNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTNode_replaceChild" "', argument " "3"" of type '" "ASTNode *""'");
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ASTNode_replaceChild" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (int)(arg1)->replaceChild(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_replaceChild__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_replaceChild" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_replaceChild" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_ASTNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTNode_replaceChild" "', argument " "3"" of type '" "ASTNode *""'");
  }
  result = (int)(arg1)->replaceChild(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_replaceChild(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASTNode_replaceChild", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_ASTNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ASTNode_replaceChild__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_ASTNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ASTNode_replaceChild__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASTNode_replaceChild'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASTNode::replaceChild(unsigned int,ASTNode *,bool)\n"
    "    ASTNode::replaceChild(unsigned int,ASTNode *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASTNode_insertChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_insertChild", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_insertChild" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_insertChild" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_ASTNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTNode_insertChild" "', argument " "3"" of type '" "ASTNode *""'");
  }
  result = (int)(arg1)->insertChild(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_deepCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_deepCopy" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (ASTNode *)((ASTNode const *)arg1)->deepCopy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ASTNode *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_getChild", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getChild" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_getChild" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ASTNode *)((ASTNode const *)arg1)->getChild(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getLeftChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getLeftChild" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (ASTNode *)((ASTNode const *)arg1)->getLeftChild();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getRightChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getRightChild" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (ASTNode *)((ASTNode const *)arg1)->getRightChild();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getNumChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getNumChildren" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (unsigned int)((ASTNode const *)arg1)->getNumChildren();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_addSemanticsAnnotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  XMLNode *arg2 = (XMLNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_addSemanticsAnnotation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_addSemanticsAnnotation" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_XMLNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_addSemanticsAnnotation" "', argument " "2"" of type '" "XMLNode *""'");
  }
  result = (int)(arg1)->addSemanticsAnnotation(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getNumSemanticsAnnotations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getNumSemanticsAnnotations" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (unsigned int)((ASTNode const *)arg1)->getNumSemanticsAnnotations();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getSemanticsAnnotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  XMLNode *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_getSemanticsAnnotation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getSemanticsAnnotation" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_getSemanticsAnnotation" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (XMLNode *)((ASTNode const *)arg1)->getSemanticsAnnotation(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getCharacter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getCharacter" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (char)((ASTNode const *)arg1)->getCharacter();
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getId" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = ((ASTNode const *)arg1)->getId();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getClass" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = ((ASTNode const *)arg1)->getClass();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getStyle" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = ((ASTNode const *)arg1)->getStyle();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getInteger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getInteger" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (long)((ASTNode const *)arg1)->getInteger();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getName" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (char *)((ASTNode const *)arg1)->getName();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getOperatorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getOperatorName" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (char *)((ASTNode const *)arg1)->getOperatorName();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getNumerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getNumerator" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (long)((ASTNode const *)arg1)->getNumerator();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getDenominator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getDenominator" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (long)((ASTNode const *)arg1)->getDenominator();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getReal" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (double)((ASTNode const *)arg1)->getReal();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getMantissa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getMantissa" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (double)((ASTNode const *)arg1)->getMantissa();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getExponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  long result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getExponent" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (long)((ASTNode const *)arg1)->getExponent();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getValue" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (double)((ASTNode const *)arg1)->getValue();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getPrecedence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getPrecedence" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (int)((ASTNode const *)arg1)->getPrecedence();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNodeType_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getType" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (ASTNodeType_t)((ASTNode const *)arg1)->getType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getUnits" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = ((ASTNode const *)arg1)->getUnits();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isAvogadro(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isAvogadro" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isAvogadro();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isBoolean(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isBoolean" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isBoolean();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_returnsBoolean__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  Model *arg2 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_returnsBoolean" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_returnsBoolean" "', argument " "2"" of type '" "Model const *""'"); 
  }
  arg2 = reinterpret_cast< Model * >(argp2);
  result = (bool)((ASTNode const *)arg1)->returnsBoolean((Model const *)arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_returnsBoolean__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_returnsBoolean" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->returnsBoolean();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_returnsBoolean(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASTNode_returnsBoolean", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ASTNode_returnsBoolean__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTNode_returnsBoolean__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASTNode_returnsBoolean'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASTNode::returnsBoolean(Model const *) const\n"
    "    ASTNode::returnsBoolean() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASTNode_isConstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isConstant" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isConstant();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isCiNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isCiNumber" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isCiNumber();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isConstantNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isConstantNumber" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isConstantNumber();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isCSymbolFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isCSymbolFunction" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isCSymbolFunction();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isFunction" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isFunction();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isInfinity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isInfinity" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isInfinity();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isInteger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isInteger" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isInteger();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isLambda(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isLambda" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isLambda();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isLog10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isLog10" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isLog10();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isLogical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isLogical" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isLogical();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isName" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isName();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isNaN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isNaN" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isNaN();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isNegInfinity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isNegInfinity" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isNegInfinity();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isNumber" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isNumber();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isOperator" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isOperator();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isPiecewise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isPiecewise" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isPiecewise();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isRational(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isRational" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isRational();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isReal" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isReal();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isRelational(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isRelational" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isRelational();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isSqrt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isSqrt" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isSqrt();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isUMinus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isUMinus" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isUMinus();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isUPlus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isUPlus" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isUPlus();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isUserFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isUserFunction" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isUserFunction();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_hasTypeAndNumChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNodeType_t arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_hasTypeAndNumChildren", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_hasTypeAndNumChildren" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_hasTypeAndNumChildren" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ASTNode_hasTypeAndNumChildren" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (int)((ASTNode const *)arg1)->hasTypeAndNumChildren(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isUnknown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isUnknown" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isUnknown();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isSetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isSetId" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isSetId();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isSetClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isSetClass" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isSetClass();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isSetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isSetStyle" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isSetStyle();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isSetUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isSetUnits" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isSetUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_hasUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_hasUnits" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->hasUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setCharacter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_setCharacter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setCharacter" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_setCharacter" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  result = (int)(arg1)->setCharacter(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_setId", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setId" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_setId" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setId((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_setClass", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setClass" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_setClass" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_setClass" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setClass((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_setStyle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setStyle" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_setStyle" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_setStyle" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setStyle((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_setName", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setName" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_setName" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->setName((char const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setValue" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_setValue" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  result = (int)(arg1)->setValue(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setValue" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_setValue" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ASTNode_setValue" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  result = (int)(arg1)->setValue(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setValue__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setValue" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->setValue(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setValue__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  double arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setValue" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ASTNode_setValue" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  result = (int)(arg1)->setValue(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASTNode_setValue", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASTNode_setValue__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASTNode_setValue__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ASTNode_setValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ASTNode_setValue__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASTNode_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASTNode::setValue(long)\n"
    "    ASTNode::setValue(long,long)\n"
    "    ASTNode::setValue(double)\n"
    "    ASTNode::setValue(double,long)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASTNode_setType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_setType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setType" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_setType" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  result = (int)(arg1)->setType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_setUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setUnits" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_setUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_setUnits" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setUnits((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_swapChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_swapChildren", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_swapChildren" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_swapChildren" "', argument " "2"" of type '" "ASTNode *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (int)(arg1)->swapChildren(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_renameSIdRefs" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTNode_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_renameUnitSIdRefs" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTNode_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_replaceIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_replaceIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_replaceIDWithFunction" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_replaceIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_replaceIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTNode_replaceIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_multiplyTimeBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_multiplyTimeBy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_multiplyTimeBy" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_multiplyTimeBy" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  (arg1)->multiplyTimeBy((ASTNode const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_unsetUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_unsetUnits" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (int)(arg1)->unsetUnits();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_unsetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_unsetId" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (int)(arg1)->unsetId();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_unsetClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_unsetClass" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (int)(arg1)->unsetClass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_unsetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_unsetStyle" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (int)(arg1)->unsetStyle();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setDefinitionURL__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  XMLAttributes arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setDefinitionURL" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_XMLAttributes,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_setDefinitionURL" "', argument " "2"" of type '" "XMLAttributes""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_setDefinitionURL" "', argument " "2"" of type '" "XMLAttributes""'");
    } else {
      XMLAttributes * temp = reinterpret_cast< XMLAttributes * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int)(arg1)->setDefinitionURL(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setDefinitionURL__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setDefinitionURL" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_setDefinitionURL" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_setDefinitionURL" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setDefinitionURL((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setDefinitionURL(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASTNode_setDefinitionURL", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_XMLAttributes, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTNode_setDefinitionURL__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTNode_setDefinitionURL__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASTNode_setDefinitionURL'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASTNode::setDefinitionURL(XMLAttributes)\n"
    "    ASTNode::setDefinitionURL(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASTNode_getDefinitionURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  XMLAttributes *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getDefinitionURL" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (XMLAttributes *)((ASTNode const *)arg1)->getDefinitionURL();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XMLAttributes, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_replaceArgument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_replaceArgument", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_replaceArgument" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_replaceArgument" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_replaceArgument" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTNode_replaceArgument" "', argument " "3"" of type '" "ASTNode *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceArgument((std::string const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getParentSBMLObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBase *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getParentSBMLObject" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (SBase *)((ASTNode const *)arg1)->getParentSBMLObject();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_unsetParentSBMLObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_unsetParentSBMLObject" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (int)(arg1)->unsetParentSBMLObject();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isSetParentSBMLObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isSetParentSBMLObject" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isSetParentSBMLObject();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_reduceToBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_reduceToBinary" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  (arg1)->reduceToBinary();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_unsetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_unsetUserData" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (int)(arg1)->unsetUserData();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isSetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isSetUserData" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isSetUserData();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isWellFormedASTNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isWellFormedASTNode" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isWellFormedASTNode();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_hasCorrectNumberArguments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_hasCorrectNumberArguments" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->hasCorrectNumberArguments();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getDefinitionURLString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getDefinitionURLString" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = ((ASTNode const *)arg1)->getDefinitionURLString();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_representsBvar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_representsBvar" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->representsBvar();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isBvar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isBvar" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isBvar();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_setBvar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_setBvar" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  (arg1)->setBvar();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_usesL3V2MathConstructs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_usesL3V2MathConstructs" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->usesL3V2MathConstructs();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_usesRateOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_usesRateOf" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->usesRateOf();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isQualifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isQualifier" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isQualifier();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_isSemantics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_isSemantics" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (bool)((ASTNode const *)arg1)->isSemantics();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getNumBvars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getNumBvars" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (unsigned int)((ASTNode const *)arg1)->getNumBvars();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_addPlugin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTBasePlugin *arg2 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_addPlugin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_addPlugin" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_addPlugin" "', argument " "2"" of type '" "ASTBasePlugin *""'"); 
  }
  arg2 = reinterpret_cast< ASTBasePlugin * >(argp2);
  (arg1)->addPlugin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_loadASTPlugins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_loadASTPlugins", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_loadASTPlugins" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_loadASTPlugins" "', argument " "2"" of type '" "SBMLNamespaces const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces * >(argp2);
  (arg1)->loadASTPlugins((SBMLNamespaces const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_loadASTPlugin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNode_loadASTPlugin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_loadASTPlugin" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_loadASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_loadASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->loadASTPlugin((std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getASTPlugin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getASTPlugin" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "SBMLNamespaces const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces * >(argp2);
  result = (ASTBasePlugin *)(arg1)->getASTPlugin((SBMLNamespaces const *)arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getASTPlugin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getASTPlugin" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  result = (ASTBasePlugin *)(arg1)->getASTPlugin(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getASTPlugin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getASTPlugin" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ASTNode_getASTPlugin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ASTNode_getASTPlugin" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (ASTBasePlugin *)(arg1)->getASTPlugin((std::string const &)*arg2,arg3,arg4);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getASTPlugin__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getASTPlugin" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ASTNode_getASTPlugin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (ASTBasePlugin *)(arg1)->getASTPlugin((std::string const &)*arg2,arg3);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getASTPlugin__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getASTPlugin" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ASTBasePlugin *)(arg1)->getASTPlugin((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getASTPlugin__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getASTPlugin" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "SBMLNamespaces const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces * >(argp2);
  result = (ASTBasePlugin *)((ASTNode const *)arg1)->getASTPlugin((SBMLNamespaces const *)arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getASTPlugin__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getASTPlugin" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  result = (ASTBasePlugin *)((ASTNode const *)arg1)->getASTPlugin(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getASTPlugin__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getASTPlugin" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ASTNode_getASTPlugin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ASTNode_getASTPlugin" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (ASTBasePlugin *)((ASTNode const *)arg1)->getASTPlugin((std::string const &)*arg2,arg3,arg4);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getASTPlugin__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getASTPlugin" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ASTNode_getASTPlugin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (ASTBasePlugin *)((ASTNode const *)arg1)->getASTPlugin((std::string const &)*arg2,arg3);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getASTPlugin__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getASTPlugin" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_getASTPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ASTBasePlugin *)((ASTNode const *)arg1)->getASTPlugin((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getASTPlugin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASTNode_getASTPlugin", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTNode_getASTPlugin__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTNode_getASTPlugin__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASTNode_getASTPlugin__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASTNode_getASTPlugin__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTNode_getASTPlugin__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTNode_getASTPlugin__SWIG_9(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ASTNode_getASTPlugin__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ASTNode_getASTPlugin__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ASTNode_getASTPlugin__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ASTNode_getASTPlugin__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASTNode_getASTPlugin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASTNode::getASTPlugin(SBMLNamespaces const *)\n"
    "    ASTNode::getASTPlugin(ASTNodeType_t)\n"
    "    ASTNode::getASTPlugin(std::string const &,bool,bool)\n"
    "    ASTNode::getASTPlugin(std::string const &,bool)\n"
    "    ASTNode::getASTPlugin(std::string const &)\n"
    "    ASTNode::getASTPlugin(SBMLNamespaces const *) const\n"
    "    ASTNode::getASTPlugin(ASTNodeType_t) const\n"
    "    ASTNode::getASTPlugin(std::string const &,bool,bool) const\n"
    "    ASTNode::getASTPlugin(std::string const &,bool) const\n"
    "    ASTNode::getASTPlugin(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASTNode_getPlugin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getPlugin" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_getPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_getPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ASTBasePlugin *)(arg1)->getPlugin((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getPlugin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getPlugin" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNode_getPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNode_getPlugin" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ASTBasePlugin *)((ASTNode const *)arg1)->getPlugin((std::string const &)*arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getPlugin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getPlugin" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_getPlugin" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ASTBasePlugin *)(arg1)->getPlugin(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getPlugin__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  ASTBasePlugin *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getPlugin" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNode_getPlugin" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ASTBasePlugin *)((ASTNode const *)arg1)->getPlugin(arg2);
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getPlugin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASTNode_getPlugin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASTNode_getPlugin__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASTNode_getPlugin__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTNode_getPlugin__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTNode_getPlugin__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASTNode_getPlugin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASTNode::getPlugin(std::string const &)\n"
    "    ASTNode::getPlugin(std::string const &) const\n"
    "    ASTNode::getPlugin(unsigned int)\n"
    "    ASTNode::getPlugin(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASTNode_getNumPlugins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getNumPlugins" "', argument " "1"" of type '" "ASTNode const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = (unsigned int)((ASTNode const *)arg1)->getNumPlugins();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNode_getListOfNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode *arg1 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ListWrapper< ASTNode > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNode_getListOfNodes" "', argument " "1"" of type '" "ASTNode *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode * >(argp1);
  result = ASTNode_getListOfNodes(arg1);
  resultobj = SWIG_NewPointerObj((new ListWrapper< ASTNode >(static_cast< const ListWrapper< ASTNode >& >(result))), SWIGTYPE_p_ListWrapperT_ASTNode_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ASTNode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ASTNode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ASTNode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_readMathMLFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "readMathMLFromString" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ASTNode_t *)readMathMLFromString((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_readMathMLFromStringWithNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  XMLNamespaces_t *arg2 = (XMLNamespaces_t *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ASTNode_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "readMathMLFromStringWithNamespaces", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "readMathMLFromStringWithNamespaces" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_XMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "readMathMLFromStringWithNamespaces" "', argument " "2"" of type '" "XMLNamespaces_t *""'"); 
  }
  arg2 = reinterpret_cast< XMLNamespaces_t * >(argp2);
  result = (ASTNode_t *)readMathMLFromStringWithNamespaces((char const *)arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_writeMathMLToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode_t *arg1 = (ASTNode_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeMathMLToString" "', argument " "1"" of type '" "ASTNode_t const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode_t * >(argp1);
  result = (char *)writeMathMLToString((ASTNode const *)arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_writeMathMLWithNamespaceToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode_t *arg1 = (ASTNode_t *) 0 ;
  SBMLNamespaces_t *arg2 = (SBMLNamespaces_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "writeMathMLWithNamespaceToString", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeMathMLWithNamespaceToString" "', argument " "1"" of type '" "ASTNode_t const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writeMathMLWithNamespaceToString" "', argument " "2"" of type '" "SBMLNamespaces_t *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces_t * >(argp2);
  result = (char *)writeMathMLWithNamespaceToString((ASTNode const *)arg1,arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parseFormula(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parseFormula" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ASTNode_t *)SBML_parseFormula((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formulaToL3String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode_t *arg1 = (ASTNode_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formulaToL3String" "', argument " "1"" of type '" "ASTNode_t const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode_t * >(argp1);
  result = (char *)SBML_formulaToL3String((ASTNode const *)arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formulaToL3StringWithSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode_t *arg1 = (ASTNode_t *) 0 ;
  L3ParserSettings_t *arg2 = (L3ParserSettings_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "formulaToL3StringWithSettings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formulaToL3StringWithSettings" "', argument " "1"" of type '" "ASTNode_t const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formulaToL3StringWithSettings" "', argument " "2"" of type '" "L3ParserSettings_t const *""'"); 
  }
  arg2 = reinterpret_cast< L3ParserSettings_t * >(argp2);
  result = (char *)SBML_formulaToL3StringWithSettings((ASTNode const *)arg1,(L3ParserSettings const *)arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formulaToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNode_t *arg1 = (ASTNode_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formulaToString" "', argument " "1"" of type '" "ASTNode_t const *""'"); 
  }
  arg1 = reinterpret_cast< ASTNode_t * >(argp1);
  result = (char *)SBML_formulaToString((ASTNode const *)arg1);
  resultobj = SWIG_FromCharPtr((const char *)result);
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parseL3Formula(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNode_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parseL3Formula" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (ASTNode_t *)SBML_parseL3Formula((char const *)arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parseL3FormulaWithModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  Model_t *arg2 = (Model_t *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ASTNode_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "parseL3FormulaWithModel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parseL3FormulaWithModel" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parseL3FormulaWithModel" "', argument " "2"" of type '" "Model_t const *""'"); 
  }
  arg2 = reinterpret_cast< Model_t * >(argp2);
  result = (ASTNode_t *)SBML_parseL3FormulaWithModel((char const *)arg1,(Model const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parseL3FormulaWithSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  L3ParserSettings_t *arg2 = (L3ParserSettings_t *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ASTNode_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "parseL3FormulaWithSettings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parseL3FormulaWithSettings" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parseL3FormulaWithSettings" "', argument " "2"" of type '" "L3ParserSettings_t const *""'"); 
  }
  arg2 = reinterpret_cast< L3ParserSettings_t * >(argp2);
  result = (ASTNode_t *)SBML_parseL3FormulaWithSettings((char const *)arg1,(L3ParserSettings const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_getDefaultL3ParserSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "getDefaultL3ParserSettings", 0, 0, 0)) SWIG_fail;
  result = (L3ParserSettings_t *)SBML_getDefaultL3ParserSettings();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_L3ParserSettings, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getLastParseL3Error(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "getLastParseL3Error", 0, 0, 0)) SWIG_fail;
  result = (char *)SBML_getLastParseL3Error();
  resultobj = SWIG_FromCharPtr((const char *)result);
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SBML_deleteL3Parser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "SBML_deleteL3Parser", 0, 0, 0)) SWIG_fail;
  SBML_deleteL3Parser();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_L3ParserSettings__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  L3ParserSettings *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  result = (L3ParserSettings *)new L3ParserSettings();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_L3ParserSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_L3ParserSettings__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  ParseLogType_t arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  SBMLNamespaces *arg7 = (SBMLNamespaces *) 0 ;
  bool arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  L3ParserSettings *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L3ParserSettings" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L3ParserSettings" "', argument " "2"" of type '" "ParseLogType_t""'");
  } 
  arg2 = static_cast< ParseLogType_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L3ParserSettings" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_L3ParserSettings" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_L3ParserSettings" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_L3ParserSettings" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_L3ParserSettings" "', argument " "7"" of type '" "SBMLNamespaces *""'"); 
  }
  arg7 = reinterpret_cast< SBMLNamespaces * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_L3ParserSettings" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_L3ParserSettings" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  result = (L3ParserSettings *)new L3ParserSettings(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_L3ParserSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_L3ParserSettings__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  ParseLogType_t arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  SBMLNamespaces *arg7 = (SBMLNamespaces *) 0 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  L3ParserSettings *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L3ParserSettings" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L3ParserSettings" "', argument " "2"" of type '" "ParseLogType_t""'");
  } 
  arg2 = static_cast< ParseLogType_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L3ParserSettings" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_L3ParserSettings" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_L3ParserSettings" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_L3ParserSettings" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_L3ParserSettings" "', argument " "7"" of type '" "SBMLNamespaces *""'"); 
  }
  arg7 = reinterpret_cast< SBMLNamespaces * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_L3ParserSettings" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  result = (L3ParserSettings *)new L3ParserSettings(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_L3ParserSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_L3ParserSettings__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  ParseLogType_t arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  SBMLNamespaces *arg7 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  L3ParserSettings *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L3ParserSettings" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L3ParserSettings" "', argument " "2"" of type '" "ParseLogType_t""'");
  } 
  arg2 = static_cast< ParseLogType_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L3ParserSettings" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_L3ParserSettings" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_L3ParserSettings" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_L3ParserSettings" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_L3ParserSettings" "', argument " "7"" of type '" "SBMLNamespaces *""'"); 
  }
  arg7 = reinterpret_cast< SBMLNamespaces * >(argp7);
  result = (L3ParserSettings *)new L3ParserSettings(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_L3ParserSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_L3ParserSettings__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  ParseLogType_t arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  L3ParserSettings *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L3ParserSettings" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L3ParserSettings" "', argument " "2"" of type '" "ParseLogType_t""'");
  } 
  arg2 = static_cast< ParseLogType_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L3ParserSettings" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_L3ParserSettings" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_L3ParserSettings" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_L3ParserSettings" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (L3ParserSettings *)new L3ParserSettings(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_L3ParserSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_L3ParserSettings__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Model *arg1 = (Model *) 0 ;
  ParseLogType_t arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  L3ParserSettings *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L3ParserSettings" "', argument " "1"" of type '" "Model *""'"); 
  }
  arg1 = reinterpret_cast< Model * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L3ParserSettings" "', argument " "2"" of type '" "ParseLogType_t""'");
  } 
  arg2 = static_cast< ParseLogType_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L3ParserSettings" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_L3ParserSettings" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_L3ParserSettings" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (L3ParserSettings *)new L3ParserSettings(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_L3ParserSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_L3ParserSettings__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  L3ParserSettings *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_L3ParserSettings,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L3ParserSettings" "', argument " "1"" of type '" "L3ParserSettings const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L3ParserSettings" "', argument " "1"" of type '" "L3ParserSettings const &""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  result = (L3ParserSettings *)new L3ParserSettings((L3ParserSettings const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_L3ParserSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_L3ParserSettings(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_L3ParserSettings", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_L3ParserSettings__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_L3ParserSettings, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_L3ParserSettings__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_L3ParserSettings__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_L3ParserSettings__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_L3ParserSettings__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_L3ParserSettings__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_SBMLNamespaces, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_L3ParserSettings__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L3ParserSettings'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    L3ParserSettings::L3ParserSettings()\n"
    "    L3ParserSettings::L3ParserSettings(Model *,ParseLogType_t,bool,bool,bool,bool,SBMLNamespaces *,bool,bool)\n"
    "    L3ParserSettings::L3ParserSettings(Model *,ParseLogType_t,bool,bool,bool,bool,SBMLNamespaces *,bool)\n"
    "    L3ParserSettings::L3ParserSettings(Model *,ParseLogType_t,bool,bool,bool,bool,SBMLNamespaces *)\n"
    "    L3ParserSettings::L3ParserSettings(Model *,ParseLogType_t,bool,bool,bool,bool)\n"
    "    L3ParserSettings::L3ParserSettings(Model *,ParseLogType_t,bool,bool,bool)\n"
    "    L3ParserSettings::L3ParserSettings(L3ParserSettings const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_L3ParserSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_L3ParserSettings" "', argument " "1"" of type '" "L3ParserSettings *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_setModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  Model *arg2 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "L3ParserSettings_setModel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_setModel" "', argument " "1"" of type '" "L3ParserSettings *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L3ParserSettings_setModel" "', argument " "2"" of type '" "Model const *""'"); 
  }
  arg2 = reinterpret_cast< Model * >(argp2);
  (arg1)->setModel((Model const *)arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_getModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Model *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_getModel" "', argument " "1"" of type '" "L3ParserSettings const *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  result = (Model *)((L3ParserSettings const *)arg1)->getModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Model, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_unsetModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_unsetModel" "', argument " "1"" of type '" "L3ParserSettings *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  (arg1)->unsetModel();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_setParseLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  ParseLogType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "L3ParserSettings_setParseLog", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_setParseLog" "', argument " "1"" of type '" "L3ParserSettings *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L3ParserSettings_setParseLog" "', argument " "2"" of type '" "ParseLogType_t""'");
  } 
  arg2 = static_cast< ParseLogType_t >(val2);
  (arg1)->setParseLog(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_getParseLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ParseLogType_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_getParseLog" "', argument " "1"" of type '" "L3ParserSettings const *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  result = (ParseLogType_t)((L3ParserSettings const *)arg1)->getParseLog();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_setParseCollapseMinus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "L3ParserSettings_setParseCollapseMinus", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_setParseCollapseMinus" "', argument " "1"" of type '" "L3ParserSettings *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L3ParserSettings_setParseCollapseMinus" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setParseCollapseMinus(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_getParseCollapseMinus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_getParseCollapseMinus" "', argument " "1"" of type '" "L3ParserSettings const *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  result = (bool)((L3ParserSettings const *)arg1)->getParseCollapseMinus();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_setParseUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "L3ParserSettings_setParseUnits", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_setParseUnits" "', argument " "1"" of type '" "L3ParserSettings *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L3ParserSettings_setParseUnits" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setParseUnits(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_getParseUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_getParseUnits" "', argument " "1"" of type '" "L3ParserSettings const *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  result = (bool)((L3ParserSettings const *)arg1)->getParseUnits();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_setParseAvogadroCsymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "L3ParserSettings_setParseAvogadroCsymbol", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_setParseAvogadroCsymbol" "', argument " "1"" of type '" "L3ParserSettings *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L3ParserSettings_setParseAvogadroCsymbol" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setParseAvogadroCsymbol(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_getParseAvogadroCsymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_getParseAvogadroCsymbol" "', argument " "1"" of type '" "L3ParserSettings const *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  result = (bool)((L3ParserSettings const *)arg1)->getParseAvogadroCsymbol();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_setComparisonCaseSensitivity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "L3ParserSettings_setComparisonCaseSensitivity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_setComparisonCaseSensitivity" "', argument " "1"" of type '" "L3ParserSettings *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L3ParserSettings_setComparisonCaseSensitivity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setComparisonCaseSensitivity(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_getComparisonCaseSensitivity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_getComparisonCaseSensitivity" "', argument " "1"" of type '" "L3ParserSettings const *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  result = (bool)((L3ParserSettings const *)arg1)->getComparisonCaseSensitivity();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_setParseModuloL3v2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "L3ParserSettings_setParseModuloL3v2", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_setParseModuloL3v2" "', argument " "1"" of type '" "L3ParserSettings *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L3ParserSettings_setParseModuloL3v2" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setParseModuloL3v2(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_getParseModuloL3v2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_getParseModuloL3v2" "', argument " "1"" of type '" "L3ParserSettings const *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  result = (bool)((L3ParserSettings const *)arg1)->getParseModuloL3v2();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_setParseL3v2Functions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "L3ParserSettings_setParseL3v2Functions", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_setParseL3v2Functions" "', argument " "1"" of type '" "L3ParserSettings *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L3ParserSettings_setParseL3v2Functions" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setParseL3v2Functions(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_getParseL3v2Functions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_getParseL3v2Functions" "', argument " "1"" of type '" "L3ParserSettings const *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  result = (bool)((L3ParserSettings const *)arg1)->getParseL3v2Functions();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_setParsePackageMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  ExtendedMathType_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "L3ParserSettings_setParsePackageMath", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_setParsePackageMath" "', argument " "1"" of type '" "L3ParserSettings *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L3ParserSettings_setParsePackageMath" "', argument " "2"" of type '" "ExtendedMathType_t""'");
  } 
  arg2 = static_cast< ExtendedMathType_t >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "L3ParserSettings_setParsePackageMath" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setParsePackageMath(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_getParsePackageMath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  ExtendedMathType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "L3ParserSettings_getParsePackageMath", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_getParsePackageMath" "', argument " "1"" of type '" "L3ParserSettings const *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L3ParserSettings_getParsePackageMath" "', argument " "2"" of type '" "ExtendedMathType_t""'");
  } 
  arg2 = static_cast< ExtendedMathType_t >(val2);
  result = (bool)((L3ParserSettings const *)arg1)->getParsePackageMath(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_L3ParserSettings_visitPackageInfixSyntax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  L3ParserSettings *arg1 = (L3ParserSettings *) 0 ;
  ASTNode_t *arg2 = (ASTNode_t *) 0 ;
  ASTNode_t *arg3 = (ASTNode_t *) 0 ;
  StringBuffer_t *arg4 = (StringBuffer_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "L3ParserSettings_visitPackageInfixSyntax", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_L3ParserSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L3ParserSettings_visitPackageInfixSyntax" "', argument " "1"" of type '" "L3ParserSettings const *""'"); 
  }
  arg1 = reinterpret_cast< L3ParserSettings * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L3ParserSettings_visitPackageInfixSyntax" "', argument " "2"" of type '" "ASTNode_t const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode_t * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L3ParserSettings_visitPackageInfixSyntax" "', argument " "3"" of type '" "ASTNode_t const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_StringBuffer_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "L3ParserSettings_visitPackageInfixSyntax" "', argument " "4"" of type '" "StringBuffer_t *""'"); 
  }
  arg4 = reinterpret_cast< StringBuffer_t * >(argp4);
  ((L3ParserSettings const *)arg1)->visitPackageInfixSyntax((ASTNode_t const *)arg2,(ASTNode_t const *)arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *L3ParserSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_L3ParserSettings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *L3ParserSettings_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_DefinitionURLRegistry_getInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  DefinitionURLRegistry *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DefinitionURLRegistry_getInstance", 0, 0, 0)) SWIG_fail;
  result = (DefinitionURLRegistry *) &DefinitionURLRegistry::getInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DefinitionURLRegistry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefinitionURLRegistry_addDefinitionURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int arg2 ;
  int res1 = SWIG_OLDOBJ ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "DefinitionURLRegistry_addDefinitionURL", 2, 2, swig_obj)) SWIG_fail;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefinitionURLRegistry_addDefinitionURL" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefinitionURLRegistry_addDefinitionURL" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefinitionURLRegistry_addDefinitionURL" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)DefinitionURLRegistry::addDefinitionURL((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefinitionURLRegistry_getNumDefinitionURLs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "DefinitionURLRegistry_getNumDefinitionURLs", 0, 0, 0)) SWIG_fail;
  result = (int)DefinitionURLRegistry::getNumDefinitionURLs();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefinitionURLRegistry_addSBMLDefinitions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "DefinitionURLRegistry_addSBMLDefinitions", 0, 0, 0)) SWIG_fail;
  DefinitionURLRegistry::addSBMLDefinitions();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefinitionURLRegistry_getCoreDefinitionsAdded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "DefinitionURLRegistry_getCoreDefinitionsAdded", 0, 0, 0)) SWIG_fail;
  result = (bool)DefinitionURLRegistry::getCoreDefinitionsAdded();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefinitionURLRegistry_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefinitionURLRegistry_getType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefinitionURLRegistry_getType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (int)DefinitionURLRegistry::getType((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefinitionURLRegistry_getDefinitionUrlByIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DefinitionURLRegistry_getDefinitionUrlByIndex" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = DefinitionURLRegistry::getDefinitionUrlByIndex(arg1);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefinitionURLRegistry_clearDefinitions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "DefinitionURLRegistry_clearDefinitions", 0, 0, 0)) SWIG_fail;
  DefinitionURLRegistry::clearDefinitions();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DefinitionURLRegistry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  DefinitionURLRegistry *arg1 = (DefinitionURLRegistry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DefinitionURLRegistry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefinitionURLRegistry" "', argument " "1"" of type '" "DefinitionURLRegistry *""'"); 
  }
  arg1 = reinterpret_cast< DefinitionURLRegistry * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefinitionURLRegistry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_DefinitionURLRegistry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MathFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  MathFilter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (MathFilter *)new SwigDirector_MathFilter(arg1); 
  } else {
    result = (MathFilter *)new MathFilter(); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MathFilter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MathFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  MathFilter *arg1 = (MathFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MathFilter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MathFilter" "', argument " "1"" of type '" "MathFilter *""'"); 
  }
  arg1 = reinterpret_cast< MathFilter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MathFilter_filter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  MathFilter *arg1 = (MathFilter *) 0 ;
  SBase *arg2 = (SBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "MathFilter_filter", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MathFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MathFilter_filter" "', argument " "1"" of type '" "MathFilter *""'"); 
  }
  arg1 = reinterpret_cast< MathFilter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MathFilter_filter" "', argument " "2"" of type '" "SBase const *""'"); 
  }
  arg2 = reinterpret_cast< SBase * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    if (upcall) {
      result = (bool)(arg1)->MathFilter::filter((SBase const *)arg2);
    } else {
      result = (bool)(arg1)->filter((SBase const *)arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_MathFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  MathFilter *arg1 = (MathFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MathFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_MathFilter" "', argument " "1"" of type '" "MathFilter *""'"); 
  }
  arg1 = reinterpret_cast< MathFilter * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MathFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MathFilter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MathFilter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ASTNodeValues_t_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNodeValues_t_name_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeValues_t_name_set" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNodeValues_t_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNodeValues_t_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeValues_t_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeValues_t_name_get" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  result = (std::string *) & ((arg1)->name);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeValues_t_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNodeValues_t_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeValues_t_type_set" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNodeValues_t_type_set" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeValues_t_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTNodeType_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeValues_t_type_get" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  result = (ASTNodeType_t) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeValues_t_isFunction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNodeValues_t_isFunction_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeValues_t_isFunction_set" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNodeValues_t_isFunction_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isFunction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeValues_t_isFunction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeValues_t_isFunction_get" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  result = (bool) ((arg1)->isFunction);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeValues_t_csymbolURL_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNodeValues_t_csymbolURL_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeValues_t_csymbolURL_set" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNodeValues_t_csymbolURL_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNodeValues_t_csymbolURL_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->csymbolURL = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeValues_t_csymbolURL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeValues_t_csymbolURL_get" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  result = (std::string *) & ((arg1)->csymbolURL);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeValues_t_allowedChildrenType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  AllowedChildrenType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNodeValues_t_allowedChildrenType_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeValues_t_allowedChildrenType_set" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTNodeValues_t_allowedChildrenType_set" "', argument " "2"" of type '" "AllowedChildrenType_t""'");
  } 
  arg2 = static_cast< AllowedChildrenType_t >(val2);
  if (arg1) (arg1)->allowedChildrenType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeValues_t_allowedChildrenType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AllowedChildrenType_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeValues_t_allowedChildrenType_get" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  result = (AllowedChildrenType_t) ((arg1)->allowedChildrenType);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeValues_t_numAllowedChildren_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  std::vector< unsigned int > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTNodeValues_t_numAllowedChildren_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeValues_t_numAllowedChildren_set" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_unsigned_int_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTNodeValues_t_numAllowedChildren_set" "', argument " "2"" of type '" "std::vector< unsigned int >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTNodeValues_t_numAllowedChildren_set" "', argument " "2"" of type '" "std::vector< unsigned int >""'");
    } else {
      std::vector< unsigned int > * temp = reinterpret_cast< std::vector< unsigned int > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  if (arg1) (arg1)->numAllowedChildren = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTNodeValues_t_numAllowedChildren_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTNodeValues_t_numAllowedChildren_get" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  result =  ((arg1)->numAllowedChildren);
  resultobj = SWIG_NewPointerObj((new std::vector< unsigned int >(static_cast< const std::vector< unsigned int >& >(result))), SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ASTNodeValues_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ASTNodeValues_t", 0, 0, 0)) SWIG_fail;
  result = (ASTNodeValues_t *)new ASTNodeValues_t();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNodeValues_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ASTNodeValues_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTNodeValues_t *arg1 = (ASTNodeValues_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTNodeValues_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ASTNodeValues_t" "', argument " "1"" of type '" "ASTNodeValues_t *""'"); 
  }
  arg1 = reinterpret_cast< ASTNodeValues_t * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ASTNodeValues_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ASTNodeValues_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ASTNodeValues_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ASTBasePlugin_getStringFor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_getStringFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getStringFor" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTBasePlugin_getStringFor" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  result = (std::string *) &((ASTBasePlugin const *)arg1)->getStringFor(arg2);
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getConstCharFor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_getConstCharFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getConstCharFor" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTBasePlugin_getConstCharFor" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  result = (char *)((ASTBasePlugin const *)arg1)->getConstCharFor(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getConstCharCsymbolURLFor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_getConstCharCsymbolURLFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getConstCharCsymbolURLFor" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTBasePlugin_getConstCharCsymbolURLFor" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  result = (char *)((ASTBasePlugin const *)arg1)->getConstCharCsymbolURLFor(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getASTNodeTypeFor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  ASTNodeType_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_getASTNodeTypeFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getASTNodeTypeFor" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_getASTNodeTypeFor" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_getASTNodeTypeFor" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ASTNodeType_t)((ASTBasePlugin const *)arg1)->getASTNodeTypeFor((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getASTNodeTypeForCSymbolURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  ASTNodeType_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_getASTNodeTypeForCSymbolURL", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getASTNodeTypeForCSymbolURL" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_getASTNodeTypeForCSymbolURL" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_getASTNodeTypeForCSymbolURL" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (ASTNodeType_t)((ASTBasePlugin const *)arg1)->getASTNodeTypeForCSymbolURL((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_hasCorrectNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  SBMLNamespaces *arg2 = (SBMLNamespaces *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_hasCorrectNamespace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_hasCorrectNamespace" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLNamespaces, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_hasCorrectNamespace" "', argument " "2"" of type '" "SBMLNamespaces *""'"); 
  }
  arg2 = reinterpret_cast< SBMLNamespaces * >(argp2);
  result = (bool)((ASTBasePlugin const *)arg1)->hasCorrectNamespace(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_defines__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_defines" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTBasePlugin_defines" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  result = (bool)((ASTBasePlugin const *)arg1)->defines(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_defines__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_defines" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_defines" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_defines" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ASTBasePlugin_defines" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)((ASTBasePlugin const *)arg1)->defines((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_defines__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_defines" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_defines" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_defines" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((ASTBasePlugin const *)arg1)->defines((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_defines(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASTBasePlugin_defines", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASTBasePlugin_defines__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTBasePlugin_defines__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ASTBasePlugin_defines__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASTBasePlugin_defines'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASTBasePlugin::defines(ASTNodeType_t) const\n"
    "    ASTBasePlugin::defines(std::string const &,bool) const\n"
    "    ASTBasePlugin::defines(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_isFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_isFunction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_isFunction" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTBasePlugin_isFunction" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  result = (bool)((ASTBasePlugin const *)arg1)->isFunction(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getNumAllowedChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< unsigned int > result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_getNumAllowedChildren", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getNumAllowedChildren" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTBasePlugin_getNumAllowedChildren" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  result = ((ASTBasePlugin const *)arg1)->getNumAllowedChildren(arg2);
  resultobj = SWIG_NewPointerObj((new std::vector< unsigned int >(static_cast< const std::vector< unsigned int >& >(result))), SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_isLogical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_isLogical", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_isLogical" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTBasePlugin_isLogical" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  result = (bool)((ASTBasePlugin const *)arg1)->isLogical(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_isMathMLNodeTag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_isMathMLNodeTag" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_isMathMLNodeTag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_isMathMLNodeTag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((ASTBasePlugin const *)arg1)->isMathMLNodeTag((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_isMathMLNodeTag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_isMathMLNodeTag" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTBasePlugin_isMathMLNodeTag" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  result = (bool)((ASTBasePlugin const *)arg1)->isMathMLNodeTag(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_isMathMLNodeTag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASTBasePlugin_isMathMLNodeTag", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASTBasePlugin_isMathMLNodeTag__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(argv[1], (std::basic_string<char>**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTBasePlugin_isMathMLNodeTag__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASTBasePlugin_isMathMLNodeTag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASTBasePlugin::isMathMLNodeTag(std::string const &) const\n"
    "    ASTBasePlugin::isMathMLNodeTag(ASTNodeType_t) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getExtendedMathType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ExtendedMathType_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getExtendedMathType" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (ExtendedMathType_t)((ASTBasePlugin const *)arg1)->getExtendedMathType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_evaluateASTNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  Model *arg3 = (Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_evaluateASTNode" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_evaluateASTNode" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Model, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTBasePlugin_evaluateASTNode" "', argument " "3"" of type '" "Model const *""'"); 
  }
  arg3 = reinterpret_cast< Model * >(argp3);
  result = (double)((ASTBasePlugin const *)arg1)->evaluateASTNode((ASTNode const *)arg2,(Model const *)arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_evaluateASTNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_evaluateASTNode" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_evaluateASTNode" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (double)((ASTBasePlugin const *)arg1)->evaluateASTNode((ASTNode const *)arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_evaluateASTNode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASTBasePlugin_evaluateASTNode", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ASTNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASTBasePlugin_evaluateASTNode__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ASTNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Model, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ASTBasePlugin_evaluateASTNode__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASTBasePlugin_evaluateASTNode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASTBasePlugin::evaluateASTNode(ASTNode const *,Model const *) const\n"
    "    ASTBasePlugin::evaluateASTNode(ASTNode const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getUnitDefinitionFromPackage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  UnitFormulaFormatter *arg2 = (UnitFormulaFormatter *) 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  UnitDefinition *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_getUnitDefinitionFromPackage", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getUnitDefinitionFromPackage" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_UnitFormulaFormatter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_getUnitDefinitionFromPackage" "', argument " "2"" of type '" "UnitFormulaFormatter *""'"); 
  }
  arg2 = reinterpret_cast< UnitFormulaFormatter * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTBasePlugin_getUnitDefinitionFromPackage" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ASTBasePlugin_getUnitDefinitionFromPackage" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ASTBasePlugin_getUnitDefinitionFromPackage" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (UnitDefinition *)((ASTBasePlugin const *)arg1)->getUnitDefinitionFromPackage(arg2,(ASTNode const *)arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnitDefinition, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getASTNodeValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ASTNodeValues_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_getASTNodeValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getASTNodeValue" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTBasePlugin_getASTNodeValue" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (ASTNodeValues_t *)((ASTBasePlugin const *)arg1)->getASTNodeValue(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNodeValues_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_allowedInFunctionDefinition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNodeType_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_allowedInFunctionDefinition", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_allowedInFunctionDefinition" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASTBasePlugin_allowedInFunctionDefinition" "', argument " "2"" of type '" "ASTNodeType_t""'");
  } 
  arg2 = static_cast< ASTNodeType_t >(val2);
  result = (int)((ASTBasePlugin const *)arg1)->allowedInFunctionDefinition(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ASTBasePlugin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ASTBasePlugin" "', argument " "1"" of type '" "ASTBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ASTBasePlugin *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_clone" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (ASTBasePlugin *)((ASTBasePlugin const *)arg1)->clone();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      SWIG_POINTER_OWN |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getElementNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getElementNamespace" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (std::string *) &((ASTBasePlugin const *)arg1)->getElementNamespace();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getPrefix" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (std::string *) &((ASTBasePlugin const *)arg1)->getPrefix();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getPackageName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getPackageName" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (std::string *) &((ASTBasePlugin const *)arg1)->getPackageName();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_setSBMLExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  SBMLExtension *arg2 = (SBMLExtension *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_setSBMLExtension", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_setSBMLExtension" "', argument " "1"" of type '" "ASTBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SBMLExtension, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_setSBMLExtension" "', argument " "2"" of type '" "SBMLExtension const *""'"); 
  }
  arg2 = reinterpret_cast< SBMLExtension * >(argp2);
  result = (int)(arg1)->setSBMLExtension((SBMLExtension const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_setPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_setPrefix", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_setPrefix" "', argument " "1"" of type '" "ASTBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_setPrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_setPrefix" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setPrefix((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_connectToParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_connectToParent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_connectToParent" "', argument " "1"" of type '" "ASTBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_connectToParent" "', argument " "2"" of type '" "ASTNode *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  (arg1)->connectToParent(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_enablePackageInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_enablePackageInternal", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_enablePackageInternal" "', argument " "1"" of type '" "ASTBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_enablePackageInternal" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTBasePlugin_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_enablePackageInternal" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ASTBasePlugin_enablePackageInternal" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->enablePackageInternal((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_stripPackage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_stripPackage", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_stripPackage" "', argument " "1"" of type '" "ASTBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_stripPackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_stripPackage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ASTBasePlugin_stripPackage" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->stripPackage((std::string const &)*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getURI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getURI" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = ((ASTBasePlugin const *)arg1)->getURI();
  resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getParentASTObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ASTNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getParentASTObject" "', argument " "1"" of type '" "ASTBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (ASTNode *)(arg1)->getParentASTObject();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getParentASTObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ASTNode *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getParentASTObject" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (ASTNode *)((ASTBasePlugin const *)arg1)->getParentASTObject();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASTNode, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getParentASTObject(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASTBasePlugin_getParentASTObject", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ASTBasePlugin_getParentASTObject__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ASTBasePlugin, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ASTBasePlugin_getParentASTObject__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASTBasePlugin_getParentASTObject'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASTBasePlugin::getParentASTObject()\n"
    "    ASTBasePlugin::getParentASTObject() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_setElementNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_setElementNamespace", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_setElementNamespace" "', argument " "1"" of type '" "ASTBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_setElementNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_setElementNamespace" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->setElementNamespace((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getLevel" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (unsigned int)((ASTBasePlugin const *)arg1)->getLevel();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getVersion" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (unsigned int)((ASTBasePlugin const *)arg1)->getVersion();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getPackageVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getPackageVersion" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (unsigned int)((ASTBasePlugin const *)arg1)->getPackageVersion();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getSBMLNamespaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SBMLNamespaces *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getSBMLNamespaces" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (SBMLNamespaces *)((ASTBasePlugin const *)arg1)->getSBMLNamespaces();
  {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), GetDowncastSwigType(result),
      0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_renameSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_renameSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_renameSIdRefs" "', argument " "1"" of type '" "ASTBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_renameSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTBasePlugin_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_renameSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_renameUnitSIdRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_renameUnitSIdRefs", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_renameUnitSIdRefs" "', argument " "1"" of type '" "ASTBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_renameUnitSIdRefs" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res3 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTBasePlugin_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_renameUnitSIdRefs" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->renameUnitSIdRefs((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_replaceIDWithFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  std::string *arg2 = 0 ;
  ASTNode *arg3 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_replaceIDWithFunction", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_replaceIDWithFunction" "', argument " "1"" of type '" "ASTBasePlugin *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  {
    std::basic_string<char> *ptr = (std::basic_string<char> *)0;
    res2 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_replaceIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_replaceIDWithFunction" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTBasePlugin_replaceIDWithFunction" "', argument " "3"" of type '" "ASTNode const *""'"); 
  }
  arg3 = reinterpret_cast< ASTNode * >(argp3);
  (arg1)->replaceIDWithFunction((std::string const &)*arg2,(ASTNode const *)arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_checkNumArguments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  std::stringstream *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_checkNumArguments", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_checkNumArguments" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_checkNumArguments" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__stringstream,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASTBasePlugin_checkNumArguments" "', argument " "3"" of type '" "std::stringstream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASTBasePlugin_checkNumArguments" "', argument " "3"" of type '" "std::stringstream &""'"); 
  }
  arg3 = reinterpret_cast< std::stringstream * >(argp3);
  result = (int)((ASTBasePlugin const *)arg1)->checkNumArguments((ASTNode const *)arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_getL3PackageInfixPrecedence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_getL3PackageInfixPrecedence" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (int)((ASTBasePlugin const *)arg1)->getL3PackageInfixPrecedence();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_hasCorrectNumArguments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_hasCorrectNumArguments", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_hasCorrectNumArguments" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_hasCorrectNumArguments" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (bool)((ASTBasePlugin const *)arg1)->hasCorrectNumArguments((ASTNode const *)arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_hasPackageOnlyInfixSyntax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_hasPackageOnlyInfixSyntax" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (bool)((ASTBasePlugin const *)arg1)->hasPackageOnlyInfixSyntax();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_hasUnambiguousPackageInfixGrammar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  ASTNode *arg2 = (ASTNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ASTBasePlugin_hasUnambiguousPackageInfixGrammar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_hasUnambiguousPackageInfixGrammar" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ASTNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASTBasePlugin_hasUnambiguousPackageInfixGrammar" "', argument " "2"" of type '" "ASTNode const *""'"); 
  }
  arg2 = reinterpret_cast< ASTNode * >(argp2);
  result = (bool)((ASTBasePlugin const *)arg1)->hasUnambiguousPackageInfixGrammar((ASTNode const *)arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASTBasePlugin_isPackageInfixFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ASTBasePlugin *arg1 = (ASTBasePlugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASTBasePlugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASTBasePlugin_isPackageInfixFunction" "', argument " "1"" of type '" "ASTBasePlugin const *""'"); 
  }
  arg1 = reinterpret_cast< ASTBasePlugin * >(argp1);
  result = (bool)((ASTBasePlugin const *)arg1)->isPackageInfixFunction();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ASTBasePlugin_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ASTBasePlugin, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

static PyMethodDef SwigMethods[] = {
	 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { "new_ModelCreatorList", _wrap_new_ModelCreatorList, METH_NOARGS, NULL},
	 { "delete_ModelCreatorList", _wrap_delete_ModelCreatorList, METH_O, NULL},
	 { "ModelCreatorList_add", _wrap_ModelCreatorList_add, METH_VARARGS, NULL},
	 { "ModelCreatorList_get", _wrap_ModelCreatorList_get, METH_VARARGS, NULL},
	 { "ModelCreatorList_prepend", _wrap_ModelCreatorList_prepend, METH_VARARGS, NULL},
	 { "ModelCreatorList_remove", _wrap_ModelCreatorList_remove, METH_VARARGS, NULL},
	 { "ModelCreatorList_getSize", _wrap_ModelCreatorList_getSize, METH_O, NULL},
	 { "ModelCreatorList_swigregister", ModelCreatorList_swigregister, METH_O, NULL},
	 { "ModelCreatorList_swiginit", ModelCreatorList_swiginit, METH_VARARGS, NULL},
	 { "new_DateList", _wrap_new_DateList, METH_NOARGS, NULL},
	 { "delete_DateList", _wrap_delete_DateList, METH_O, NULL},
	 { "DateList_add", _wrap_DateList_add, METH_VARARGS, NULL},
	 { "DateList_get", _wrap_DateList_get, METH_VARARGS, NULL},
	 { "DateList_prepend", _wrap_DateList_prepend, METH_VARARGS, NULL},
	 { "DateList_remove", _wrap_DateList_remove, METH_VARARGS, NULL},
	 { "DateList_getSize", _wrap_DateList_getSize, METH_O, NULL},
	 { "DateList_swigregister", DateList_swigregister, METH_O, NULL},
	 { "DateList_swiginit", DateList_swiginit, METH_VARARGS, NULL},
	 { "new_CVTermList", _wrap_new_CVTermList, METH_NOARGS, NULL},
	 { "delete_CVTermList", _wrap_delete_CVTermList, METH_O, NULL},
	 { "CVTermList_add", _wrap_CVTermList_add, METH_VARARGS, NULL},
	 { "CVTermList_get", _wrap_CVTermList_get, METH_VARARGS, NULL},
	 { "CVTermList_prepend", _wrap_CVTermList_prepend, METH_VARARGS, NULL},
	 { "CVTermList_remove", _wrap_CVTermList_remove, METH_VARARGS, NULL},
	 { "CVTermList_getSize", _wrap_CVTermList_getSize, METH_O, NULL},
	 { "CVTermList_swigregister", CVTermList_swigregister, METH_O, NULL},
	 { "CVTermList_swiginit", CVTermList_swiginit, METH_VARARGS, NULL},
	 { "new_ASTNodeList", _wrap_new_ASTNodeList, METH_NOARGS, NULL},
	 { "delete_ASTNodeList", _wrap_delete_ASTNodeList, METH_O, NULL},
	 { "ASTNodeList_add", _wrap_ASTNodeList_add, METH_VARARGS, NULL},
	 { "ASTNodeList_get", _wrap_ASTNodeList_get, METH_VARARGS, NULL},
	 { "ASTNodeList_prepend", _wrap_ASTNodeList_prepend, METH_VARARGS, NULL},
	 { "ASTNodeList_remove", _wrap_ASTNodeList_remove, METH_VARARGS, NULL},
	 { "ASTNodeList_getSize", _wrap_ASTNodeList_getSize, METH_O, NULL},
	 { "ASTNodeList_swigregister", ASTNodeList_swigregister, METH_O, NULL},
	 { "ASTNodeList_swiginit", ASTNodeList_swiginit, METH_VARARGS, NULL},
	 { "new_SBMLNamespacesList", _wrap_new_SBMLNamespacesList, METH_NOARGS, NULL},
	 { "delete_SBMLNamespacesList", _wrap_delete_SBMLNamespacesList, METH_O, NULL},
	 { "SBMLNamespacesList_add", _wrap_SBMLNamespacesList_add, METH_VARARGS, NULL},
	 { "SBMLNamespacesList_get", _wrap_SBMLNamespacesList_get, METH_VARARGS, NULL},
	 { "SBMLNamespacesList_prepend", _wrap_SBMLNamespacesList_prepend, METH_VARARGS, NULL},
	 { "SBMLNamespacesList_remove", _wrap_SBMLNamespacesList_remove, METH_VARARGS, NULL},
	 { "SBMLNamespacesList_getSize", _wrap_SBMLNamespacesList_getSize, METH_O, NULL},
	 { "SBMLNamespacesList_swigregister", SBMLNamespacesList_swigregister, METH_O, NULL},
	 { "SBMLNamespacesList_swiginit", SBMLNamespacesList_swiginit, METH_VARARGS, NULL},
	 { "new_SBaseList", _wrap_new_SBaseList, METH_NOARGS, NULL},
	 { "delete_SBaseList", _wrap_delete_SBaseList, METH_O, NULL},
	 { "SBaseList_add", _wrap_SBaseList_add, METH_VARARGS, NULL},
	 { "SBaseList_get", _wrap_SBaseList_get, METH_VARARGS, NULL},
	 { "SBaseList_prepend", _wrap_SBaseList_prepend, METH_VARARGS, NULL},
	 { "SBaseList_remove", _wrap_SBaseList_remove, METH_VARARGS, NULL},
	 { "SBaseList_getSize", _wrap_SBaseList_getSize, METH_O, NULL},
	 { "SBaseList_swigregister", SBaseList_swigregister, METH_O, NULL},
	 { "SBaseList_swiginit", SBaseList_swiginit, METH_VARARGS, NULL},
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, "delete_SwigPyIterator(SwigPyIterator self)"},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, "SwigPyIterator_value(SwigPyIterator self) -> PyObject *"},
	 { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, "SwigPyIterator_incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"},
	 { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, "SwigPyIterator_decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"},
	 { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, "SwigPyIterator_distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"},
	 { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, "SwigPyIterator_equal(SwigPyIterator self, SwigPyIterator x) -> bool"},
	 { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, "SwigPyIterator_copy(SwigPyIterator self) -> SwigPyIterator"},
	 { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, "SwigPyIterator_next(SwigPyIterator self) -> PyObject *"},
	 { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, "SwigPyIterator___next__(SwigPyIterator self) -> PyObject *"},
	 { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, "SwigPyIterator_previous(SwigPyIterator self) -> PyObject *"},
	 { "SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, "SwigPyIterator_advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"},
	 { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, "SwigPyIterator___eq__(SwigPyIterator self, SwigPyIterator x) -> bool"},
	 { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, "SwigPyIterator___ne__(SwigPyIterator self, SwigPyIterator x) -> bool"},
	 { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, "SwigPyIterator___iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"},
	 { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, "SwigPyIterator___isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"},
	 { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, "SwigPyIterator___add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, "\n"
		"SwigPyIterator___sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator\n"
		"SwigPyIterator___sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t\n"
		""},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
	 { "string_length", _wrap_string_length, METH_O, "string_length(string self) -> std::basic_string< char >::size_type"},
	 { "string_max_size", _wrap_string_max_size, METH_O, "string_max_size(string self) -> std::basic_string< char >::size_type"},
	 { "string_copy", _wrap_string_copy, METH_VARARGS, "string_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"},
	 { "string_c_str", _wrap_string_c_str, METH_O, "string_c_str(string self) -> char const *"},
	 { "string_find", _wrap_string_find, METH_VARARGS, "\n"
		"string_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\n"
		"string_find(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type\n"
		"string_find(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type\n"
		""},
	 { "string_rfind", _wrap_string_rfind, METH_VARARGS, "\n"
		"string_rfind(string self, string __str, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> std::basic_string< char >::size_type\n"
		"string_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\n"
		"string_rfind(string self, char __c, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> std::basic_string< char >::size_type\n"
		""},
	 { "string_find_first_of", _wrap_string_find_first_of, METH_VARARGS, "\n"
		"string_find_first_of(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type\n"
		"string_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\n"
		"string_find_first_of(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type\n"
		""},
	 { "string_find_last_of", _wrap_string_find_last_of, METH_VARARGS, "\n"
		"string_find_last_of(string self, string __str, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> std::basic_string< char >::size_type\n"
		"string_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\n"
		"string_find_last_of(string self, char __c, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> std::basic_string< char >::size_type\n"
		""},
	 { "string_find_first_not_of", _wrap_string_find_first_not_of, METH_VARARGS, "\n"
		"string_find_first_not_of(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type\n"
		"string_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\n"
		"string_find_first_not_of(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type\n"
		""},
	 { "string_find_last_not_of", _wrap_string_find_last_not_of, METH_VARARGS, "\n"
		"string_find_last_not_of(string self, string __str, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> std::basic_string< char >::size_type\n"
		"string_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\n"
		"string_find_last_not_of(string self, char __c, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> std::basic_string< char >::size_type\n"
		""},
	 { "string_substr", _wrap_string_substr, METH_VARARGS, "string_substr(string self, std::basic_string< char >::size_type __pos=0, std::basic_string< char >::size_type __n=std::basic_string< char >::npos) -> string"},
	 { "string_empty", _wrap_string_empty, METH_O, "string_empty(string self) -> bool"},
	 { "string_size", _wrap_string_size, METH_O, "string_size(string self) -> std::basic_string< char >::size_type"},
	 { "string_swap", _wrap_string_swap, METH_VARARGS, "string_swap(string self, string v)"},
	 { "string_erase", _wrap_string_erase, METH_VARARGS, "\n"
		"string_erase(string self, std::basic_string< char >::size_type __pos=0, std::basic_string< char >::size_type __n=std::basic_string< char >::npos) -> string\n"
		"string_erase(string self, std::basic_string< char >::iterator pos) -> std::basic_string< char >::iterator\n"
		"string_erase(string self, std::basic_string< char >::iterator first, std::basic_string< char >::iterator last) -> std::basic_string< char >::iterator\n"
		""},
	 { "new_string", _wrap_new_string, METH_VARARGS, "\n"
		"string(char const * __s, std::basic_string< char >::size_type __n)\n"
		"string()\n"
		"string(string other)\n"
		"new_string(std::basic_string< char >::size_type size, std::basic_string< char >::value_type value) -> string\n"
		""},
	 { "string_assign", _wrap_string_assign, METH_VARARGS, "\n"
		"string_assign(string self, string __str) -> string\n"
		"string_assign(string self, string __str, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> string\n"
		"string_assign(string self, char const * __s, std::basic_string< char >::size_type __n) -> string\n"
		"string_assign(string self, std::basic_string< char >::size_type n, std::basic_string< char >::value_type x)\n"
		""},
	 { "string_resize", _wrap_string_resize, METH_VARARGS, "\n"
		"string_resize(string self, std::basic_string< char >::size_type new_size)\n"
		"string_resize(string self, std::basic_string< char >::size_type new_size, std::basic_string< char >::value_type x)\n"
		""},
	 { "string_iterator", _wrap_string_iterator, METH_O, "string_iterator(string self) -> SwigPyIterator"},
	 { "string___nonzero__", _wrap_string___nonzero__, METH_O, "string___nonzero__(string self) -> bool"},
	 { "string___bool__", _wrap_string___bool__, METH_O, "string___bool__(string self) -> bool"},
	 { "string___len__", _wrap_string___len__, METH_O, "string___len__(string self) -> std::basic_string< char >::size_type"},
	 { "string___getslice__", _wrap_string___getslice__, METH_VARARGS, "string___getslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j) -> string"},
	 { "string___setslice__", _wrap_string___setslice__, METH_VARARGS, "\n"
		"string___setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j)\n"
		"string___setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j, string v)\n"
		""},
	 { "string___delslice__", _wrap_string___delslice__, METH_VARARGS, "string___delslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j)"},
	 { "string___delitem__", _wrap_string___delitem__, METH_VARARGS, "\n"
		"string___delitem__(string self, std::basic_string< char >::difference_type i)\n"
		"string___delitem__(string self, PySliceObject * slice)\n"
		""},
	 { "string___getitem__", _wrap_string___getitem__, METH_VARARGS, "\n"
		"string___getitem__(string self, PySliceObject * slice) -> string\n"
		"string___getitem__(string self, std::basic_string< char >::difference_type i) -> std::basic_string< char >::value_type\n"
		""},
	 { "string___setitem__", _wrap_string___setitem__, METH_VARARGS, "\n"
		"string___setitem__(string self, PySliceObject * slice, string v)\n"
		"string___setitem__(string self, PySliceObject * slice)\n"
		"string___setitem__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::value_type x)\n"
		""},
	 { "string_insert", _wrap_string_insert, METH_VARARGS, "\n"
		"string_insert(string self, std::basic_string< char >::size_type __pos1, string __str) -> string\n"
		"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\n"
		"string_insert(string self, std::basic_string< char >::size_type __pos, char const * __s, std::basic_string< char >::size_type __n) -> string\n"
		"string_insert(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n, char __c) -> string\n"
		"string_insert(string self, std::basic_string< char >::iterator pos, std::basic_string< char >::value_type x) -> std::basic_string< char >::iterator\n"
		"string_insert(string self, std::basic_string< char >::iterator pos, std::basic_string< char >::size_type n, std::basic_string< char >::value_type x)\n"
		"string_insert(string self, std::basic_string< char >::iterator __p, std::basic_string< char >::size_type __n, char __c)\n"
		""},
	 { "string_replace", _wrap_string_replace, METH_VARARGS, "\n"
		"string_replace(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n, string __str) -> string\n"
		"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\n"
		"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\n"
		"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\n"
		"string_replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, string __str) -> string\n"
		"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\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\n"
		"string_replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, char const * __k1, char const * __k2) -> string\n"
		"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\n"
		""},
	 { "string___iadd__", _wrap_string___iadd__, METH_VARARGS, "string___iadd__(string self, string v) -> string"},
	 { "string___add__", _wrap_string___add__, METH_VARARGS, "string___add__(string self, string v) -> string"},
	 { "string___radd__", _wrap_string___radd__, METH_VARARGS, "string___radd__(string self, string v) -> string"},
	 { "string___str__", _wrap_string___str__, METH_O, "string___str__(string self) -> string"},
	 { "string___rlshift__", _wrap_string___rlshift__, METH_VARARGS, "string___rlshift__(string self, ostream out) -> ostream"},
	 { "string___eq__", _wrap_string___eq__, METH_VARARGS, "string___eq__(string self, string v) -> bool"},
	 { "string___ne__", _wrap_string___ne__, METH_VARARGS, "string___ne__(string self, string v) -> bool"},
	 { "string___gt__", _wrap_string___gt__, METH_VARARGS, "string___gt__(string self, string v) -> bool"},
	 { "string___lt__", _wrap_string___lt__, METH_VARARGS, "string___lt__(string self, string v) -> bool"},
	 { "string___ge__", _wrap_string___ge__, METH_VARARGS, "string___ge__(string self, string v) -> bool"},
	 { "string___le__", _wrap_string___le__, METH_VARARGS, "string___le__(string self, string v) -> bool"},
	 { "delete_string", _wrap_delete_string, METH_O, "delete_string(string self)"},
	 { "string_swigregister", string_swigregister, METH_O, NULL},
	 { "string_swiginit", string_swiginit, METH_VARARGS, NULL},
	 { "new_ostream", _wrap_new_ostream, METH_O, "new_ostream(std::basic_streambuf< char,std::char_traits< char > > * __sb) -> ostream"},
	 { "delete_ostream", _wrap_delete_ostream, METH_O, "delete_ostream(ostream self)"},
	 { "ostream_swigregister", ostream_swigregister, METH_O, NULL},
	 { "ostream_swiginit", ostream_swiginit, METH_VARARGS, NULL},
	 { "new_ostringstream", _wrap_new_ostringstream, METH_VARARGS, "ostringstream(std::ios_base::openmode __mode=std::ios_base::out)"},
	 { "delete_ostringstream", _wrap_delete_ostringstream, METH_O, "delete_ostringstream(ostringstream self)"},
	 { "ostringstream_str", _wrap_ostringstream_str, METH_VARARGS, "\n"
		"ostringstream_str(ostringstream self) -> string\n"
		"ostringstream_str(ostringstream self, string __s)\n"
		""},
	 { "ostringstream_swigregister", ostringstream_swigregister, METH_O, NULL},
	 { "ostringstream_swiginit", ostringstream_swiginit, METH_VARARGS, NULL},
	 { "endl", _wrap_endl, METH_O, "endl(ostream arg1) -> ostream"},
	 { "flush", _wrap_flush, METH_O, "flush(ostream arg1) -> ostream"},
	 { "new_ListWrapperSBMLNamespaces", _wrap_new_ListWrapperSBMLNamespaces, METH_NOARGS, "new_ListWrapperSBMLNamespaces() -> SBMLNamespacesList"},
	 { "delete_ListWrapperSBMLNamespaces", _wrap_delete_ListWrapperSBMLNamespaces, METH_O, "delete_ListWrapperSBMLNamespaces(ListWrapperSBMLNamespaces self)"},
	 { "ListWrapperSBMLNamespaces_add", _wrap_ListWrapperSBMLNamespaces_add, METH_VARARGS, "ListWrapperSBMLNamespaces_add(ListWrapperSBMLNamespaces self, SBMLNamespaces item)"},
	 { "ListWrapperSBMLNamespaces_get", _wrap_ListWrapperSBMLNamespaces_get, METH_VARARGS, "ListWrapperSBMLNamespaces_get(ListWrapperSBMLNamespaces self, unsigned int n) -> SBMLNamespaces"},
	 { "ListWrapperSBMLNamespaces_prepend", _wrap_ListWrapperSBMLNamespaces_prepend, METH_VARARGS, "ListWrapperSBMLNamespaces_prepend(ListWrapperSBMLNamespaces self, SBMLNamespaces item)"},
	 { "ListWrapperSBMLNamespaces_remove", _wrap_ListWrapperSBMLNamespaces_remove, METH_VARARGS, "ListWrapperSBMLNamespaces_remove(ListWrapperSBMLNamespaces self, unsigned int n) -> SBMLNamespaces"},
	 { "ListWrapperSBMLNamespaces_getSize", _wrap_ListWrapperSBMLNamespaces_getSize, METH_O, "ListWrapperSBMLNamespaces_getSize(ListWrapperSBMLNamespaces self) -> unsigned int"},
	 { "ListWrapperSBMLNamespaces___len__", _wrap_ListWrapperSBMLNamespaces___len__, METH_O, "ListWrapperSBMLNamespaces___len__(ListWrapperSBMLNamespaces self) -> int"},
	 { "ListWrapperSBMLNamespaces_swigregister", ListWrapperSBMLNamespaces_swigregister, METH_O, NULL},
	 { "ListWrapperSBMLNamespaces_swiginit", ListWrapperSBMLNamespaces_swiginit, METH_VARARGS, NULL},
	 { "new_ListWrapperCVTerm", _wrap_new_ListWrapperCVTerm, METH_NOARGS, "new_ListWrapperCVTerm() -> CVTermList"},
	 { "delete_ListWrapperCVTerm", _wrap_delete_ListWrapperCVTerm, METH_O, "delete_ListWrapperCVTerm(ListWrapperCVTerm self)"},
	 { "ListWrapperCVTerm_add", _wrap_ListWrapperCVTerm_add, METH_VARARGS, "ListWrapperCVTerm_add(ListWrapperCVTerm self, CVTerm item)"},
	 { "ListWrapperCVTerm_get", _wrap_ListWrapperCVTerm_get, METH_VARARGS, "ListWrapperCVTerm_get(ListWrapperCVTerm self, unsigned int n) -> CVTerm"},
	 { "ListWrapperCVTerm_prepend", _wrap_ListWrapperCVTerm_prepend, METH_VARARGS, "ListWrapperCVTerm_prepend(ListWrapperCVTerm self, CVTerm item)"},
	 { "ListWrapperCVTerm_remove", _wrap_ListWrapperCVTerm_remove, METH_VARARGS, "ListWrapperCVTerm_remove(ListWrapperCVTerm self, unsigned int n) -> CVTerm"},
	 { "ListWrapperCVTerm_getSize", _wrap_ListWrapperCVTerm_getSize, METH_O, "ListWrapperCVTerm_getSize(ListWrapperCVTerm self) -> unsigned int"},
	 { "ListWrapperCVTerm___len__", _wrap_ListWrapperCVTerm___len__, METH_O, "ListWrapperCVTerm___len__(ListWrapperCVTerm self) -> int"},
	 { "ListWrapperCVTerm_swigregister", ListWrapperCVTerm_swigregister, METH_O, NULL},
	 { "ListWrapperCVTerm_swiginit", ListWrapperCVTerm_swiginit, METH_VARARGS, NULL},
	 { "new_ListWrapperDate", _wrap_new_ListWrapperDate, METH_NOARGS, "new_ListWrapperDate() -> DateList"},
	 { "delete_ListWrapperDate", _wrap_delete_ListWrapperDate, METH_O, "delete_ListWrapperDate(ListWrapperDate self)"},
	 { "ListWrapperDate_add", _wrap_ListWrapperDate_add, METH_VARARGS, "ListWrapperDate_add(ListWrapperDate self, Date item)"},
	 { "ListWrapperDate_get", _wrap_ListWrapperDate_get, METH_VARARGS, "ListWrapperDate_get(ListWrapperDate self, unsigned int n) -> Date"},
	 { "ListWrapperDate_prepend", _wrap_ListWrapperDate_prepend, METH_VARARGS, "ListWrapperDate_prepend(ListWrapperDate self, Date item)"},
	 { "ListWrapperDate_remove", _wrap_ListWrapperDate_remove, METH_VARARGS, "ListWrapperDate_remove(ListWrapperDate self, unsigned int n) -> Date"},
	 { "ListWrapperDate_getSize", _wrap_ListWrapperDate_getSize, METH_O, "ListWrapperDate_getSize(ListWrapperDate self) -> unsigned int"},
	 { "ListWrapperDate___len__", _wrap_ListWrapperDate___len__, METH_O, "ListWrapperDate___len__(ListWrapperDate self) -> int"},
	 { "ListWrapperDate_swigregister", ListWrapperDate_swigregister, METH_O, NULL},
	 { "ListWrapperDate_swiginit", ListWrapperDate_swiginit, METH_VARARGS, NULL},
	 { "new_ListWrapperModelCreator", _wrap_new_ListWrapperModelCreator, METH_NOARGS, "new_ListWrapperModelCreator() -> ModelCreatorList"},
	 { "delete_ListWrapperModelCreator", _wrap_delete_ListWrapperModelCreator, METH_O, "delete_ListWrapperModelCreator(ListWrapperModelCreator self)"},
	 { "ListWrapperModelCreator_add", _wrap_ListWrapperModelCreator_add, METH_VARARGS, "ListWrapperModelCreator_add(ListWrapperModelCreator self, ModelCreator item)"},
	 { "ListWrapperModelCreator_get", _wrap_ListWrapperModelCreator_get, METH_VARARGS, "ListWrapperModelCreator_get(ListWrapperModelCreator self, unsigned int n) -> ModelCreator"},
	 { "ListWrapperModelCreator_prepend", _wrap_ListWrapperModelCreator_prepend, METH_VARARGS, "ListWrapperModelCreator_prepend(ListWrapperModelCreator self, ModelCreator item)"},
	 { "ListWrapperModelCreator_remove", _wrap_ListWrapperModelCreator_remove, METH_VARARGS, "ListWrapperModelCreator_remove(ListWrapperModelCreator self, unsigned int n) -> ModelCreator"},
	 { "ListWrapperModelCreator_getSize", _wrap_ListWrapperModelCreator_getSize, METH_O, "ListWrapperModelCreator_getSize(ListWrapperModelCreator self) -> unsigned int"},
	 { "ListWrapperModelCreator___len__", _wrap_ListWrapperModelCreator___len__, METH_O, "ListWrapperModelCreator___len__(ListWrapperModelCreator self) -> int"},
	 { "ListWrapperModelCreator_swigregister", ListWrapperModelCreator_swigregister, METH_O, NULL},
	 { "ListWrapperModelCreator_swiginit", ListWrapperModelCreator_swiginit, METH_VARARGS, NULL},
	 { "new_ListWrapperSBase", _wrap_new_ListWrapperSBase, METH_NOARGS, "new_ListWrapperSBase() -> SBaseList"},
	 { "delete_ListWrapperSBase", _wrap_delete_ListWrapperSBase, METH_O, "delete_ListWrapperSBase(ListWrapperSBase self)"},
	 { "ListWrapperSBase_add", _wrap_ListWrapperSBase_add, METH_VARARGS, "ListWrapperSBase_add(ListWrapperSBase self, SBase item)"},
	 { "ListWrapperSBase_get", _wrap_ListWrapperSBase_get, METH_VARARGS, "ListWrapperSBase_get(ListWrapperSBase self, unsigned int n) -> SBase"},
	 { "ListWrapperSBase_prepend", _wrap_ListWrapperSBase_prepend, METH_VARARGS, "ListWrapperSBase_prepend(ListWrapperSBase self, SBase item)"},
	 { "ListWrapperSBase_remove", _wrap_ListWrapperSBase_remove, METH_VARARGS, "ListWrapperSBase_remove(ListWrapperSBase self, unsigned int n) -> SBase"},
	 { "ListWrapperSBase_getSize", _wrap_ListWrapperSBase_getSize, METH_O, "ListWrapperSBase_getSize(ListWrapperSBase self) -> unsigned int"},
	 { "ListWrapperSBase___len__", _wrap_ListWrapperSBase___len__, METH_O, "ListWrapperSBase___len__(ListWrapperSBase self) -> int"},
	 { "ListWrapperSBase_swigregister", ListWrapperSBase_swigregister, METH_O, NULL},
	 { "ListWrapperSBase_swiginit", ListWrapperSBase_swiginit, METH_VARARGS, NULL},
	 { "getLibSBMLVersion", _wrap_getLibSBMLVersion, METH_NOARGS, "\n"
		"getLibSBMLVersion() -> int\n"
		"\n"
		"Returns the version number of this copy of libSBML as an integer.\n"
		"\n"
		"Returns the libSBML version as an integer; version 1.2.3 becomes\n"
		"10203.\n"
		"\n"
		""},
	 { "getLibSBMLDottedVersion", _wrap_getLibSBMLDottedVersion, METH_NOARGS, "\n"
		"getLibSBMLDottedVersion() -> char const *\n"
		"\n"
		"Returns the version number of this copy of libSBML as a string.\n"
		"\n"
		"Returns the libSBML version as a string; version 1.2.3 becomes\n"
		"'1.2.3'.\n"
		"\n"
		"See also getLibSBMLVersionString().\n"
		"\n"
		""},
	 { "getLibSBMLVersionString", _wrap_getLibSBMLVersionString, METH_NOARGS, "\n"
		"getLibSBMLVersionString() -> char const *\n"
		"\n"
		"Returns the version number of this copy of libSBML as a string without\n"
		"periods.\n"
		"\n"
		"Returns the libSBML version as a string: version 1.2.3 becomes\n"
		"'10203'.\n"
		"\n"
		"See also getLibSBMLDottedVersion().\n"
		"\n"
		""},
	 { "isLibSBMLCompiledWith", _wrap_isLibSBMLCompiledWith, METH_O, "\n"
		"isLibSBMLCompiledWith(char const * option) -> int\n"
		"\n"
		"Returns an indication whether libSBML has been compiled with against a\n"
		"specific library.\n"
		"\n"
		"Parameter 'option' is the library to test against, this can be one of\n"
		"'expat', 'libxml', 'xerces-c', 'bzip2', 'zip'\n"
		"\n"
		"Returns 0 in case the libSBML has not been compiled against  that\n"
		"library and nonzero otherwise (for libraries  that define an integer\n"
		"version number that number will  be returned).\n"
		"\n"
		"See also getLibSBMLDependencyVersionOf().\n"
		"\n"
		""},
	 { "getLibSBMLDependencyVersionOf", _wrap_getLibSBMLDependencyVersionOf, METH_O, "\n"
		"getLibSBMLDependencyVersionOf(char const * option) -> char const *\n"
		"\n"
		"Returns the version string for the dependency library used.\n"
		"\n"
		"Parameter 'option' is the library for which the version should be\n"
		"retrieved, this can be one of 'expat', 'libxml', 'xerces-c', 'bzip2',\n"
		"'zip'\n"
		"\n"
		"Returns None in case libSBML has not been compiled against  that\n"
		"library and a version string otherwise.\n"
		"\n"
		"See also isLibSBMLCompiledWith().\n"
		"\n"
		""},
	 { "OperationReturnValue_toString", _wrap_OperationReturnValue_toString, METH_O, "\n"
		"OperationReturnValue_toString(int returnValue) -> char const *\n"
		"\n"
		"This method takes an SBML operation return value and returns a string\n"
		"representing the code.\n"
		"\n"
		"Parameter 'returnValue' is the operation return value to convert to a\n"
		"string.\n"
		"\n"
		"Returns a human readable name for the given operation return value .\n"
		"\n"
		"Note: The caller does not own the returned string and is therefore not\n"
		"allowed to modify it.\n"
		"\n"
		""},
	 { "new_IdList", _wrap_new_IdList, METH_VARARGS, "\n"
		"IdList()\n"
		"new_IdList(string commaSeparated) -> IdList\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "IdList_append", _wrap_IdList_append, METH_VARARGS, "\n"
		"IdList_append(IdList self, string id)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "IdList_contains", _wrap_IdList_contains, METH_VARARGS, "\n"
		"IdList_contains(IdList self, string id) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "IdList_empty", _wrap_IdList_empty, METH_O, "\n"
		"IdList_empty(IdList self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "IdList_removeIdsBefore", _wrap_IdList_removeIdsBefore, METH_VARARGS, "\n"
		"IdList_removeIdsBefore(IdList self, string id)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "IdList_size", _wrap_IdList_size, METH_O, "\n"
		"IdList_size(IdList self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "IdList_clear", _wrap_IdList_clear, METH_O, "IdList_clear(IdList self)"},
	 { "IdList_at", _wrap_IdList_at, METH_VARARGS, "IdList_at(IdList self, int n) -> string"},
	 { "delete_IdList", _wrap_delete_IdList, METH_O, "delete_IdList(IdList self)"},
	 { "IdList_swigregister", IdList_swigregister, METH_O, NULL},
	 { "IdList_swiginit", IdList_swiginit, METH_VARARGS, NULL},
	 { "new_IdentifierTransformer", _wrap_new_IdentifierTransformer, METH_O, "\n"
		"new_IdentifierTransformer(PyObject * _self) -> IdentifierTransformer\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "delete_IdentifierTransformer", _wrap_delete_IdentifierTransformer, METH_O, "delete_IdentifierTransformer(IdentifierTransformer self)"},
	 { "IdentifierTransformer_transform", _wrap_IdentifierTransformer_transform, METH_VARARGS, "IdentifierTransformer_transform(IdentifierTransformer self, SBase element) -> int"},
	 { "disown_IdentifierTransformer", _wrap_disown_IdentifierTransformer, METH_O, NULL},
	 { "IdentifierTransformer_swigregister", IdentifierTransformer_swigregister, METH_O, NULL},
	 { "IdentifierTransformer_swiginit", IdentifierTransformer_swiginit, METH_VARARGS, NULL},
	 { "new_ElementFilter", _wrap_new_ElementFilter, METH_O, "\n"
		"new_ElementFilter(PyObject * _self) -> ElementFilter\n"
		"\n"
		"Creates a new ElementFilter object.\n"
		"\n"
		""},
	 { "delete_ElementFilter", _wrap_delete_ElementFilter, METH_O, "delete_ElementFilter(ElementFilter self)"},
	 { "ElementFilter_filter", _wrap_ElementFilter_filter, METH_VARARGS, "\n"
		"ElementFilter_filter(ElementFilter self, SBase element) -> bool\n"
		"\n"
		"Predicate to test elements.\n"
		"\n"
		"This is the central predicate of the ElementFilter class.  In\n"
		"subclasses of ElementFilter, callers should implement this method such\n"
		"that it returns 'True' for 'element' arguments that are 'desirable'\n"
		"and 'False' for those that are 'undesirable' in whatever filtering\n"
		"context the ElementFilter subclass is designed to be used.\n"
		"\n"
		"Parameter 'element' is the element to be tested.\n"
		"\n"
		"Returns 'True' if the 'element' is desirable or should be kept,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "disown_ElementFilter", _wrap_disown_ElementFilter, METH_O, NULL},
	 { "ElementFilter_swigregister", ElementFilter_swigregister, METH_O, NULL},
	 { "ElementFilter_swiginit", ElementFilter_swiginit, METH_VARARGS, NULL},
	 { "new_SBMLReader", _wrap_new_SBMLReader, METH_NOARGS, "\n"
		"new_SBMLReader() -> SBMLReader\n"
		"\n"
		"Creates a new SBMLReader object and returns it.\n"
		"\n"
		"The libSBML SBMLReader object offers methods for reading SBML in XML\n"
		"form from files and text strings.\n"
		"\n"
		""},
	 { "delete_SBMLReader", _wrap_delete_SBMLReader, METH_O, "delete_SBMLReader(SBMLReader self)"},
	 { "SBMLReader_readSBML", _wrap_SBMLReader_readSBML, METH_VARARGS, "\n"
		"SBMLReader_readSBML(SBMLReader self, string filename) -> SBMLDocument\n"
		"\n"
		"Reads an SBML document from the given file.\n"
		"\n"
		"If the file named 'filename' does not exist or its content is not\n"
		"valid SBML, one or more errors will be logged with the SBMLDocument\n"
		"object returned by this method.  Callers can use the methods on\n"
		"SBMLDocument such as SBMLDocument.getNumErrors(),\n"
		"SBMLDocument.getNumErrors() and SBMLDocument.getError()\n"
		"\n"
		"to get the errors.  The object returned by SBMLDocument.getError()\n"
		"\n"
		"is an SBMLError object, and it has methods to get the error code,\n"
		"category, and severity level of the problem, as well as a textual\n"
		"description of the problem.  The possible severity levels range from\n"
		"informational messages to fatal errors; see the documentation for\n"
		"SBMLError for more information.\n"
		"\n"
		"If the file 'filename' could not be read, the file-reading error will\n"
		"appear first.  The error code  can provide a clue about what happened.\n"
		"For example, a file might be unreadable (either because it does not\n"
		"actually exist or because the user does not have the necessary access\n"
		"privileges to read it) or some sort of file operation error may have\n"
		"been reported by the underlying operating system.  Callers can check\n"
		"for these situations using a program fragment such as the following:\n"
		"\n"
		"  reader = SBMLReader()\n"
		"  if reader == None:\n"
		"    # Handle the truly exceptional case of no object created here.\n"
		"\n"
		"  doc = reader.readSBMLFromFile(filename)\n"
		"  if doc.getNumErrors() > 0:\n"
		"    if doc.getError(0).getErrorId() == XMLFileUnreadable:\n"
		"      # Handle case of unreadable file here.\n"
		"    elif doc.getError(0).getErrorId() == XMLFileOperationError:\n"
		"      # Handle case of other file error here.\n"
		"    else:\n"
		"      # Handle other error cases here.\n"
		"\n"
		"If the given filename ends with the suffix ''.gz'' (for example,\n"
		"''myfile.xml.gz'),' the file is assumed to be compressed in gzip\n"
		"format and will be automatically decompressed upon reading. Similarly,\n"
		"if the given filename ends with ''.zip'' or ''.bz2',' the file is\n"
		"assumed to be compressed in zip or bzip2 format (respectively).  Files\n"
		"whose names lack these suffixes will be read uncompressed.  Note that\n"
		"if the file is in zip format but the archive contains more than one\n"
		"file, only the first file in the archive will be read and the rest\n"
		"ignored.\n"
		"\n"
		"To read a gzip/zip file, libSBML needs to be configured and linked\n"
		"with the zlib library at compile time.  It also needs to be linked\n"
		"with the bzip2 library to read files in bzip2 format.  (Both of these\n"
		"are the default configurations for libSBML.)  Errors about unreadable\n"
		"files will be logged if a compressed filename is given and libSBML was\n"
		"not linked with the corresponding required library.\n"
		"\n"
		"This method is identical to SBMLReader.readSBMLFromFile().\n"
		"\n"
		"Parameter 'filename' is the name or full pathname of the file to be\n"
		"read.\n"
		"\n"
		"Returns a pointer to the SBMLDocument object created from the SBML\n"
		"content in 'filename'.\n"
		"\n"
		"Note: LibSBML versions 2.x and later versions behave differently in\n"
		"error handling in several respects.  One difference is how early some\n"
		"errors are caught and whether libSBML continues processing a file in\n"
		"the face of some early errors.  In general, libSBML versions after 2.x\n"
		"stop parsing SBML inputs sooner than libSBML version 2.x in the face\n"
		"of XML errors, because the errors may invalidate any further SBML\n"
		"content.  For example, a missing XML declaration at the beginning of\n"
		"the file was ignored by libSBML 2.x but in version 3.x and later, it\n"
		"will cause libSBML to stop parsing the rest of the input altogether.\n"
		"While this behavior may seem more severe and intolerant, it was\n"
		"necessary in order to provide uniform behavior regardless of which\n"
		"underlying XML parser (Expat, Xerces, libxml2) is being used by\n"
		"libSBML.  The XML parsers themselves behave differently in their error\n"
		"reporting, and sometimes libSBML has to resort to the lowest common\n"
		"denominator.\n"
		"\n"
		"See also readSBMLFromString(), SBMLError, SBMLDocument.\n"
		"\n"
		""},
	 { "SBMLReader_readSBMLFromFile", _wrap_SBMLReader_readSBMLFromFile, METH_VARARGS, "\n"
		"SBMLReader_readSBMLFromFile(SBMLReader self, string filename) -> SBMLDocument\n"
		"\n"
		"Reads an SBML document from the given file.\n"
		"\n"
		"If the file named 'filename' does not exist or its content is not\n"
		"valid SBML, one or more errors will be logged with the SBMLDocument\n"
		"object returned by this method.  Callers can use the methods on\n"
		"SBMLDocument such as SBMLDocument.getNumErrors(),\n"
		"SBMLDocument.getNumErrors() and SBMLDocument.getError()\n"
		"\n"
		"to get the errors.  The object returned by SBMLDocument.getError()\n"
		"\n"
		"is an SBMLError object, and it has methods to get the error code,\n"
		"category, and severity level of the problem, as well as a textual\n"
		"description of the problem.  The possible severity levels range from\n"
		"informational messages to fatal errors; see the documentation for\n"
		"SBMLError for more information.\n"
		"\n"
		"If the file 'filename' could not be read, the file-reading error will\n"
		"appear first.  The error code  can provide a clue about what happened.\n"
		"For example, a file might be unreadable (either because it does not\n"
		"actually exist or because the user does not have the necessary access\n"
		"privileges to read it) or some sort of file operation error may have\n"
		"been reported by the underlying operating system.  Callers can check\n"
		"for these situations using a program fragment such as the following:\n"
		"\n"
		"  reader = SBMLReader()\n"
		"  if reader == None:\n"
		"    # Handle the truly exceptional case of no object created here.\n"
		"\n"
		"  doc = reader.readSBMLFromFile(filename)\n"
		"  if doc.getNumErrors() > 0:\n"
		"    if doc.getError(0).getErrorId() == XMLFileUnreadable:\n"
		"      # Handle case of unreadable file here.\n"
		"    elif doc.getError(0).getErrorId() == XMLFileOperationError:\n"
		"      # Handle case of other file error here.\n"
		"    else:\n"
		"      # Handle other error cases here.\n"
		"\n"
		"If the given filename ends with the suffix ''.gz'' (for example,\n"
		"''myfile.xml.gz'),' the file is assumed to be compressed in gzip\n"
		"format and will be automatically decompressed upon reading. Similarly,\n"
		"if the given filename ends with ''.zip'' or ''.bz2',' the file is\n"
		"assumed to be compressed in zip or bzip2 format (respectively).  Files\n"
		"whose names lack these suffixes will be read uncompressed.  Note that\n"
		"if the file is in zip format but the archive contains more than one\n"
		"file, only the first file in the archive will be read and the rest\n"
		"ignored.\n"
		"\n"
		"To read a gzip/zip file, libSBML needs to be configured and linked\n"
		"with the zlib library at compile time.  It also needs to be linked\n"
		"with the bzip2 library to read files in bzip2 format.  (Both of these\n"
		"are the default configurations for libSBML.)  Errors about unreadable\n"
		"files will be logged if a compressed filename is given and libSBML was\n"
		"not linked with the corresponding required library.\n"
		"\n"
		"This method is identical to SBMLReader.readSBML().\n"
		"\n"
		"Parameter 'filename' is the name or full pathname of the file to be\n"
		"read.\n"
		"\n"
		"Returns a pointer to the SBMLDocument object created from the SBML\n"
		"content in 'filename'.\n"
		"\n"
		"Note: LibSBML versions 2.x and later versions behave differently in\n"
		"error handling in several respects.  One difference is how early some\n"
		"errors are caught and whether libSBML continues processing a file in\n"
		"the face of some early errors.  In general, libSBML versions after 2.x\n"
		"stop parsing SBML inputs sooner than libSBML version 2.x in the face\n"
		"of XML errors, because the errors may invalidate any further SBML\n"
		"content.  For example, a missing XML declaration at the beginning of\n"
		"the file was ignored by libSBML 2.x but in version 3.x and later, it\n"
		"will cause libSBML to stop parsing the rest of the input altogether.\n"
		"While this behavior may seem more severe and intolerant, it was\n"
		"necessary in order to provide uniform behavior regardless of which\n"
		"underlying XML parser (Expat, Xerces, libxml2) is being used by\n"
		"libSBML.  The XML parsers themselves behave differently in their error\n"
		"reporting, and sometimes libSBML has to resort to the lowest common\n"
		"denominator.\n"
		"\n"
		"See also readSBMLFromString(), SBMLError, SBMLDocument.\n"
		"\n"
		""},
	 { "SBMLReader_readSBMLFromString", _wrap_SBMLReader_readSBMLFromString, METH_VARARGS, "\n"
		"SBMLReader_readSBMLFromString(SBMLReader self, string xml) -> SBMLDocument\n"
		"\n"
		"Reads an SBML document from a text string.\n"
		"\n"
		"This method is flexible with respect to the presence of an XML\n"
		"declaration at the beginning of the string.  In particular, if the\n"
		"string in 'xml' does not begin with the XML declaration\n"
		"\n"
		"  <?xml version='1.0' encoding='UTF-8'?>\n"
		"\n"
		"then this method will automatically prepend the declaration to 'xml'.\n"
		"\n"
		"This method will log a fatal error if the content given in the\n"
		"parameter 'xml' is not in SBML format.  See the method documentation\n"
		"for SBMLReader.readSBML()\n"
		"\n"
		"for an example of code for testing the returned error code.\n"
		"\n"
		"Parameter 'xml' is a string containing a full SBML model.\n"
		"\n"
		"Returns a pointer to the SBMLDocument created from the SBML content,\n"
		"or a null pointer if 'xml' is 'None.'\n"
		"\n"
		"Note: When using this method to read an SBMLDocument that uses the\n"
		"SBML Level 3 Hierarchical Model Composition package (comp) the\n"
		"document location cannot be set automatically. Thus, if the model\n"
		"contains references to ExternalModelDefinition objects, it will be\n"
		"necessary to manually set the document URI location\n"
		"(SBMLDocument.setLocationURI()\n"
		"\n"
		") in order to facilitate resolving these models.\n"
		"\n"
		"See also SBMLReader.readSBML().\n"
		"\n"
		""},
	 { "SBMLReader_hasZlib", _wrap_SBMLReader_hasZlib, METH_NOARGS, "\n"
		"SBMLReader_hasZlib() -> bool\n"
		"\n"
		"Static method; returns 'True' if this copy of libSBML supports gzip\n"
		"and zip format compression.\n"
		"\n"
		"Returns 'True' if libSBML has been linked with the zlib library,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also SBMLReader.hasBzip2().\n"
		"\n"
		""},
	 { "SBMLReader_hasBzip2", _wrap_SBMLReader_hasBzip2, METH_NOARGS, "\n"
		"SBMLReader_hasBzip2() -> bool\n"
		"\n"
		"Static method; returns 'True' if this copy of libSBML supports bzip2\n"
		"format compression.\n"
		"\n"
		"Returns 'True' if libSBML is linked with the bzip2 libraries, 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also SBMLReader.hasZlib().\n"
		"\n"
		""},
	 { "SBMLReader_swigregister", SBMLReader_swigregister, METH_O, NULL},
	 { "SBMLReader_swiginit", SBMLReader_swiginit, METH_VARARGS, NULL},
	 { "readSBMLFromFile", _wrap_readSBMLFromFile, METH_O, "\n"
		"readSBMLFromFile(char const * filename) -> SBMLDocument\n"
		"\n"
		"Reads an SBML document from the given file.\n"
		"\n"
		"If the file named 'filename' does not exist or its content is not\n"
		"valid SBML, one or more errors will be logged with the SBMLDocument\n"
		"object returned by this method.  Callers can use the methods on\n"
		"SBMLDocument such as SBMLDocument.getNumErrors(),\n"
		"SBMLDocument.getNumErrors() and SBMLDocument.getError()\n"
		"\n"
		"to get the errors.  The object returned by SBMLDocument.getError()\n"
		"\n"
		"is an SBMLError object, and it has methods to get the error code,\n"
		"category, and severity level of the problem, as well as a textual\n"
		"description of the problem.  The possible severity levels range from\n"
		"informational messages to fatal errors; see the documentation for\n"
		"SBMLError for more information.\n"
		"\n"
		"If the file 'filename' could not be read, the file-reading error will\n"
		"appear first.  The error code  can provide a clue about what happened.\n"
		"For example, a file might be unreadable (either because it does not\n"
		"actually exist or because the user does not have the necessary access\n"
		"privileges to read it) or some sort of file operation error may have\n"
		"been reported by the underlying operating system.  Callers can check\n"
		"for these situations using a program fragment such as the following:\n"
		"\n"
		"  reader = SBMLReader()\n"
		"  if reader == None:\n"
		"    # Handle the truly exceptional case of no object created here.\n"
		"\n"
		"  doc = reader.readSBMLFromFile(filename)\n"
		"  if doc.getNumErrors() > 0:\n"
		"    if doc.getError(0).getErrorId() == XMLFileUnreadable:\n"
		"      # Handle case of unreadable file here.\n"
		"    elif doc.getError(0).getErrorId() == XMLFileOperationError:\n"
		"      # Handle case of other file error here.\n"
		"    else:\n"
		"      # Handle other error cases here.\n"
		"\n"
		"If the given filename ends with the suffix ''.gz'' (for example,\n"
		"''myfile.xml.gz'),' the file is assumed to be compressed in gzip\n"
		"format and will be automatically decompressed upon reading. Similarly,\n"
		"if the given filename ends with ''.zip'' or ''.bz2',' the file is\n"
		"assumed to be compressed in zip or bzip2 format (respectively).  Files\n"
		"whose names lack these suffixes will be read uncompressed.  Note that\n"
		"if the file is in zip format but the archive contains more than one\n"
		"file, only the first file in the archive will be read and the rest\n"
		"ignored.\n"
		"\n"
		"To read a gzip/zip file, libSBML needs to be configured and linked\n"
		"with the zlib library at compile time.  It also needs to be linked\n"
		"with the bzip2 library to read files in bzip2 format.  (Both of these\n"
		"are the default configurations for libSBML.)  Errors about unreadable\n"
		"files will be logged if a compressed filename is given and libSBML was\n"
		"not linked with the corresponding required library.\n"
		"\n"
		"Parameter 'filename' is the name or full pathname of the file to be\n"
		"read.\n"
		"\n"
		"Returns a pointer to the SBMLDocument structure created from the SBML\n"
		"content in 'filename'.\n"
		"\n"
		""},
	 { "readSBMLFromString", _wrap_readSBMLFromString, METH_O, "\n"
		"readSBMLFromString(char const * xml) -> SBMLDocument\n"
		"\n"
		"Reads an SBML document from a text string.\n"
		"\n"
		"This method is flexible with respect to the presence of an XML\n"
		"declaration at the beginning of the string.  In particular, if the\n"
		"string in 'xml' does not begin with the XML declaration\n"
		"\n"
		"  <?xml version='1.0' encoding='UTF-8'?>\n"
		"\n"
		"then this method will automatically prepend the declaration to 'xml'.\n"
		"\n"
		"This method will log a fatal error if the content given in the\n"
		"parameter 'xml' is not in SBML format.  See the method documentation\n"
		"for SBMLReader.readSBML()\n"
		"\n"
		"for an example of code for testing the returned error code.\n"
		"\n"
		"Parameter 'xml' is a string containing a full SBML model.\n"
		"\n"
		"Returns a pointer to the SBMLDocument structure created from the SBML\n"
		"content in 'xml'.\n"
		"\n"
		"Note: When using this method to read an SBMLDocument that uses the\n"
		"SBML Level 3 Hierarchical Model Composition package (comp) the\n"
		"document location cannot be set automatically. Thus, if the model\n"
		"contains references to ExternalModelDefinition objects, it will be\n"
		"necessary to manually set the document URI location\n"
		"(SBMLDocument.setLocationURI()\n"
		"\n"
		") in order to facilitate resolving these models.\n"
		"\n"
		""},
	 { "new_SBMLWriter", _wrap_new_SBMLWriter, METH_NOARGS, "\n"
		"new_SBMLWriter() -> SBMLWriter\n"
		"\n"
		"Creates a new SBMLWriter.\n"
		"\n"
		"The libSBML SBMLWriter objects offer methods for writing SBML in XML\n"
		"form to files and text strings.\n"
		"\n"
		""},
	 { "delete_SBMLWriter", _wrap_delete_SBMLWriter, METH_O, "delete_SBMLWriter(SBMLWriter self)"},
	 { "SBMLWriter_setProgramName", _wrap_SBMLWriter_setProgramName, METH_VARARGS, "\n"
		"SBMLWriter_setProgramName(SBMLWriter self, string name) -> int\n"
		"\n"
		"Sets the name of this program, i.e., the program that is about to\n"
		"write out the SBMLDocument.\n"
		"\n"
		"If the program name and version are set (see\n"
		"SBMLWriter.setProgramVersion()), the following XML comment, intended\n"
		"for human consumption, will be written at the beginning of the XML\n"
		"document:\n"
		"\n"
		"   <!-- Created by <program name> version <program version>\n"
		"   on yyyy-MM-dd HH:mm with libSBML version <libsbml version>. -->\n"
		"\n"
		"If the program name and version are not set at some point before\n"
		"calling the writeSBML() methods, no such comment is written out.\n"
		"\n"
		"Parameter 'name' is the name of this program (where 'this program'\n"
		"refers to program in which libSBML is embedded, not libSBML itself!)\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also setProgramVersion().\n"
		"\n"
		""},
	 { "SBMLWriter_setProgramVersion", _wrap_SBMLWriter_setProgramVersion, METH_VARARGS, "\n"
		"SBMLWriter_setProgramVersion(SBMLWriter self, string version) -> int\n"
		"\n"
		"Sets the version of this program, i.e., the program that is about to\n"
		"write out the SBMLDocument.\n"
		"\n"
		"If the program version and name are set (see\n"
		"SBMLWriter.setProgramName()), the following XML comment, intended for\n"
		"human consumption, will be written at the beginning of the document:\n"
		"\n"
		"   <!-- Created by <program name> version <program version>\n"
		"   on yyyy-MM-dd HH:mm with libSBML version <libsbml version>. -->\n"
		"\n"
		"If the program version and name are not set at some point before\n"
		"calling the writeSBML() methods, no such comment is written out.\n"
		"\n"
		"Parameter 'version' is the version of this program (where 'this\n"
		"program' refers to program in which libSBML is embedded, not libSBML\n"
		"itself!)\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also setProgramName().\n"
		"\n"
		""},
	 { "SBMLWriter_writeSBML", _wrap_SBMLWriter_writeSBML, METH_VARARGS, "\n"
		"SBMLWriter_writeSBML(SBMLWriter self, SBMLDocument d, string filename) -> bool\n"
		"SBMLWriter_writeSBML(SBMLWriter self, SBMLDocument d, ostream stream) -> bool\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeSBML(SBMLDocument d, string filename)\n"
		"\n"
		"Writes the given SBML document to filename.\n"
		"\n"
		"If the given filename ends with the suffix \".gz\" (for example,\n"
		"\"myfile.xml.gz\"), libSBML assumes the caller wants the file to be\n"
		"written compressed in gzip format. Similarly, if the given filename\n"
		"ends with \".zip\" or \".bz2\", libSBML assumes the caller wants the\n"
		"file to be compressed in zip or bzip2 format (respectively). Files\n"
		"whose names lack these suffixes will be written uncompressed. Special\n"
		"considerations for the zip format: If the given filename ends with\n"
		"\".zip\", the file placed in the zip archive will have the suffix\n"
		"\".xml\" or \".sbml\".  For example, the file in the zip archive will\n"
		"be named \"test.xml\" if the given filename is \"test.xml.zip\" or\n"
		"\"test.zip\". Similarly, the filename in the archive will be\n"
		"\"test.sbml\" if the given filename is \"test.sbml.zip\".\n"
		"\n"
		"Parameter 'd' is the SBML document to be written.\n"
		"\n"
		"Parameter 'filename' is the name or full pathname of the file where\n"
		"the SBML is to be written.\n"
		"\n"
		"Returns 'True' on success and 'False' if the filename could not be\n"
		"opened for writing.\n"
		"\n"
		"Note: To write a gzip/zip file, libSBML needs to be configured and\n"
		"linked with the zlib library at compile time.  It also needs to be\n"
		"linked with the bzip2 library to write files in bzip2 format.  (Both\n"
		"of these are the default configurations for libSBML.)  Errors about\n"
		"unreadable files will be logged and this method will return false if a\n"
		"compressed filename is given and libSBML was not linked with the\n"
		"corresponding required library.\n"
		"\n"
		"See also setProgramVersion(), setProgramName().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeSBML(SBMLDocument d, std::ostream stream)\n"
		"\n"
		"Writes the given SBML document to the output stream.\n"
		"\n"
		"Parameter 'd' is the SBML document to be written.\n"
		"\n"
		"Parameter 'stream' is the stream object where the SBML is to be\n"
		"written.\n"
		"\n"
		"Returns 'True' on success and 'False' if one of the underlying parser\n"
		"components fail (rare).\n"
		"\n"
		"See also setProgramVersion(), setProgramName().\n"
		"\n"
		""},
	 { "SBMLWriter_writeToString", _wrap_SBMLWriter_writeToString, METH_VARARGS, "\n"
		"SBMLWriter_writeToString(SBMLWriter self, SBMLDocument d) -> char *\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLWriter_writeSBMLToFile", _wrap_SBMLWriter_writeSBMLToFile, METH_VARARGS, "\n"
		"SBMLWriter_writeSBMLToFile(SBMLWriter self, SBMLDocument d, string filename) -> bool\n"
		"\n"
		"Writes the given SBML document to filename.\n"
		"\n"
		"If the given filename ends with the suffix \".gz\" (for example,\n"
		"\"myfile.xml.gz\"), libSBML assumes the caller wants the file to be\n"
		"written compressed in gzip format. Similarly, if the given filename\n"
		"ends with \".zip\" or \".bz2\", libSBML assumes the caller wants the\n"
		"file to be compressed in zip or bzip2 format (respectively). Files\n"
		"whose names lack these suffixes will be written uncompressed. Special\n"
		"considerations for the zip format: If the given filename ends with\n"
		"\".zip\", the file placed in the zip archive will have the suffix\n"
		"\".xml\" or \".sbml\".  For example, the file in the zip archive will\n"
		"be named \"test.xml\" if the given filename is \"test.xml.zip\" or\n"
		"\"test.zip\". Similarly, the filename in the archive will be\n"
		"\"test.sbml\" if the given filename is \"test.sbml.zip\".\n"
		"\n"
		"Parameter 'd' is the SBML document to be written.\n"
		"\n"
		"Parameter 'filename' is the name or full pathname of the file where\n"
		"the SBML is to be written.\n"
		"\n"
		"Returns 'True' on success and 'False' if the filename could not be\n"
		"opened for writing.\n"
		"\n"
		"Note: To write a gzip/zip file, libSBML needs to be configured and\n"
		"linked with the zlib library at compile time.  It also needs to be\n"
		"linked with the bzip2 library to write files in bzip2 format.  (Both\n"
		"of these are the default configurations for libSBML.)  Errors about\n"
		"unreadable files will be logged and this method will return false if a\n"
		"compressed filename is given and libSBML was not linked with the\n"
		"corresponding required library.\n"
		"\n"
		"See also setProgramVersion(), setProgramName().\n"
		"\n"
		""},
	 { "SBMLWriter_writeSBMLToString", _wrap_SBMLWriter_writeSBMLToString, METH_VARARGS, "\n"
		"SBMLWriter_writeSBMLToString(SBMLWriter self, SBMLDocument d) -> char *\n"
		"\n"
		"Writes the given SBML document to an in-memory string and returns a\n"
		"pointer to it.\n"
		"\n"
		"The string is owned by the caller and should be freed (with 'free())'\n"
		"when no longer needed.\n"
		"\n"
		"Parameter 'd' is the SBML document to be written.\n"
		"\n"
		"Returns the string on success and '0' if one of the underlying parser\n"
		"components fail.\n"
		"\n"
		"See also setProgramVersion(), setProgramName().\n"
		"\n"
		""},
	 { "SBMLWriter_hasZlib", _wrap_SBMLWriter_hasZlib, METH_NOARGS, "\n"
		"SBMLWriter_hasZlib() -> bool\n"
		"\n"
		"Predicate returning 'True' if this copy of libSBML has been linked\n"
		"with the zlib library.\n"
		"\n"
		"LibSBML supports reading and writing files compressed with either\n"
		"bzip2 or zip/gzip compression.  The facility depends on libSBML having\n"
		"been compiled with the necessary support libraries.  This method\n"
		"allows a calling program to inquire whether that is the case for the\n"
		"copy of libSBML it is using.\n"
		"\n"
		"Returns 'True' if libSBML is linked with zlib, 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also SBMLWriter.hasBzip2() .\n"
		"\n"
		""},
	 { "SBMLWriter_hasBzip2", _wrap_SBMLWriter_hasBzip2, METH_NOARGS, "\n"
		"SBMLWriter_hasBzip2() -> bool\n"
		"\n"
		"Predicate returning 'True' if this copy of libSBML has been linked\n"
		"with the bzip2 library.\n"
		"\n"
		"LibSBML supports reading and writing files compressed with either\n"
		"bzip2 or zip/gzip compression.  The facility depends on libSBML having\n"
		"been compiled with the necessary support libraries.  This method\n"
		"allows a calling program to inquire whether that is the case for the\n"
		"copy of libSBML it is using.\n"
		"\n"
		"Returns 'True' if libSBML is linked with bzip2, 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also SBMLWriter.hasZlib() .\n"
		"\n"
		""},
	 { "SBMLWriter_swigregister", SBMLWriter_swigregister, METH_O, NULL},
	 { "SBMLWriter_swiginit", SBMLWriter_swiginit, METH_VARARGS, NULL},
	 { "writeSBML", _wrap_writeSBML, METH_VARARGS, "\n"
		"writeSBML(SBMLDocument d, char const * filename) -> int\n"
		"\n"
		"Writes the given SBML document 'd' to the file named by 'filename'.\n"
		"This convenience function is functionally equivalent to:\n"
		"\n"
		"SBMLWriter_writeSBML(SBMLWriter_create(), d, filename);\n"
		"\n"
		"If the given filename ends with the suffix \".gz\" (for example,\n"
		"\"myfile.xml.gz\"), libSBML assumes the caller wants the file to be\n"
		"written compressed in gzip format. Similarly, if the given filename\n"
		"ends with \".zip\" or \".bz2\", libSBML assumes the caller wants the\n"
		"file to be compressed in zip or bzip2 format (respectively). Files\n"
		"whose names lack these suffixes will be written uncompressed. Special\n"
		"considerations for the zip format: If the given filename ends with\n"
		"\".zip\", the file placed in the zip archive will have the suffix\n"
		"\".xml\" or \".sbml\".  For example, the file in the zip archive will\n"
		"be named \"test.xml\" if the given filename is \"test.xml.zip\" or\n"
		"\"test.zip\". Similarly, the filename in the archive will be\n"
		"\"test.sbml\" if the given filename is \"test.sbml.zip\".\n"
		"\n"
		"Parameter 'd' is the SBMLDocument object to be written out in XML\n"
		"format.\n"
		"\n"
		"Parameter 'filename' is a string giving the path to a file where the\n"
		"XML content is to be written.\n"
		"\n"
		"Returns '1' (true) on success and '0' (false) if 'filename' could not\n"
		"be written.  Some possible reasons for failure include (a) being\n"
		"unable to open the file, and (b) using a filename that indicates a\n"
		"compressed SBML file (i.e., a filename ending in \".zip\" or similar)\n"
		"when the compression functionality has not been enabled in the\n"
		"underlying copy of libSBML.\n"
		"\n"
		"See also SBMLWriter.hasZlib(), SBMLWriter.hasBzip2().\n"
		"\n"
		""},
	 { "writeSBMLToString", _wrap_writeSBMLToString, METH_O, "\n"
		"writeSBMLToString(SBMLDocument d) -> char *\n"
		"\n"
		"Writes the given SBML document 'd' to an in-memory string and returns\n"
		"a pointer to it.  The string is owned by the caller and should be\n"
		"freed (with free()) when no longer needed.  This convenience function\n"
		"is functionally equivalent to:\n"
		"\n"
		"SBMLWriter_writeSBMLToString(SBMLWriter_create(), d);\n"
		"\n"
		"but does not require the caller to create an SBMLWriter object first.\n"
		"\n"
		"Parameter 'd' is an SBMLDocument object to be written out in XML\n"
		"format.\n"
		"\n"
		"Returns the string on success and 'None' if one of the underlying\n"
		"parser components fail.\n"
		"\n"
		""},
	 { "writeSBMLToFile", _wrap_writeSBMLToFile, METH_VARARGS, "\n"
		"writeSBMLToFile(SBMLDocument d, char const * filename) -> int\n"
		"\n"
		"Writes the given SBML document 'd' to the file 'filename'. This\n"
		"convenience function is functionally equivalent to:\n"
		"\n"
		"SBMLWriter_writeSBMLToFile(SBMLWriter_create(), d, filename);\n"
		"\n"
		"but that does not require the caller to create an SBMLWriter object\n"
		"first.\n"
		"\n"
		"If the given filename ends with the suffix \".gz\" (for example,\n"
		"\"myfile.xml.gz\"), libSBML assumes the caller wants the file to be\n"
		"written compressed in gzip format. Similarly, if the given filename\n"
		"ends with \".zip\" or \".bz2\", libSBML assumes the caller wants the\n"
		"file to be compressed in zip or bzip2 format (respectively). Files\n"
		"whose names lack these suffixes will be written uncompressed. Special\n"
		"considerations for the zip format: If the given filename ends with\n"
		"\".zip\", the file placed in the zip archive will have the suffix\n"
		"\".xml\" or \".sbml\".  For example, the file in the zip archive will\n"
		"be named \"test.xml\" if the given filename is \"test.xml.zip\" or\n"
		"\"test.zip\". Similarly, the filename in the archive will be\n"
		"\"test.sbml\" if the given filename is \"test.sbml.zip\".\n"
		"\n"
		"Parameter 'd' is an SBMLDocument object to be written out in XML\n"
		"format.\n"
		"\n"
		"Parameter 'filename' is a string giving the path to a file where the\n"
		"XML content is to be written.\n"
		"\n"
		"Returns '1' (true) on success and '0' (false) if 'filename' could not\n"
		"be written.  Some possible reasons for failure include (a) being\n"
		"unable to open the file, and (b) using a filename that indicates a\n"
		"compressed SBML file (i.e., a filename ending in \".zip\" or similar)\n"
		"when the compression functionality has not been enabled in the\n"
		"underlying copy of libSBML.\n"
		"\n"
		"See also SBMLWriter.hasZlib(), SBMLWriter.hasBzip2().\n"
		"\n"
		""},
	 { "SBMLTypeCode_toString", _wrap_SBMLTypeCode_toString, METH_VARARGS, "\n"
		"SBMLTypeCode_toString(int tc, char const * pkgName) -> char const *\n"
		"\n"
		"This method takes an SBML type code and returns a string representing\n"
		"the code.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are known as SBML type codes.  In the Python language interface\n"
		"for libSBML, the type codes are defined as static integer constants in\n"
		"the interface class 'libsbml'.  The names of the type codes all begin\n"
		"with the characters 'SBML_.'\n"
		"\n"
		"Returns a human readable name for the given SBML type code.\n"
		"\n"
		"Note: The caller does not own the returned string and is therefore not\n"
		"allowed to modify it.\n"
		"\n"
		""},
	 { "delete_SBase", _wrap_delete_SBase, METH_O, "delete_SBase(SBase self)"},
	 { "SBase_clone", _wrap_SBase_clone, METH_O, "\n"
		"SBase_clone(SBase self) -> SBase\n"
		"\n"
		"Creates and returns a deep copy of this SBase object.\n"
		"\n"
		"Returns the (deep) copy of this SBase object.\n"
		"\n"
		""},
	 { "SBase_getElementBySId", _wrap_SBase_getElementBySId, METH_VARARGS, "\n"
		"SBase_getElementBySId(SBase self, string id) -> SBase\n"
		"SBase_getElementBySId(SBase self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given 'id' in the\n"
		"model-wide 'SId' namespace, or 'None' if no such object is found.\n"
		"\n"
		"Parameter 'id' is string representing the 'id' attribute value of the\n"
		"object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given identifier.\n"
		"\n"
		""},
	 { "SBase_getElementByMetaId", _wrap_SBase_getElementByMetaId, METH_VARARGS, "\n"
		"SBase_getElementByMetaId(SBase self, string metaid) -> SBase\n"
		"SBase_getElementByMetaId(SBase self, string metaid) -> SBase\n"
		"\n"
		"Returns the first child element it can find with a specific 'metaid'\n"
		"attribute value, or 'None' if no such object is found.\n"
		"\n"
		"The optional attribute named 'metaid', present on every major SBML\n"
		"component type, is for supporting metadata annotations using RDF\n"
		"(Resource Description Format).  The attribute value has the data type\n"
		"XML ID, the XML identifier type, which means each 'metaid' value must\n"
		"be globally unique within an SBML file.  The latter point is\n"
		"important, because the uniqueness criterion applies across any\n"
		"attribute with type ID anywhere in the file, not just the 'metaid'\n"
		"attribute used by SBML---something to be aware of if your application-\n"
		"specific XML content inside the 'annotation' subelement happens to use\n"
		"the XML ID type.  Although SBML itself specifies the use of XML ID\n"
		"only for the 'metaid' attribute, SBML-compatible applications should\n"
		"be careful if they use XML ID's in XML portions of a model that are\n"
		"not defined by SBML, such as in the application-specific content of\n"
		"the 'annotation' subelement.  Finally, note that LibSBML does not\n"
		"provide an explicit XML ID data type; it uses ordinary character\n"
		"strings, which is easier for applications to support.\n"
		"\n"
		"Parameter 'metaid' is string representing the 'metaid' attribute value\n"
		"of the object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given meta-\n"
		"identifier.\n"
		"\n"
		""},
	 { "SBase_renameSIdRefs", _wrap_SBase_renameSIdRefs, METH_VARARGS, "\n"
		"SBase_renameSIdRefs(SBase self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "SBase_renameMetaIdRefs", _wrap_SBase_renameMetaIdRefs, METH_VARARGS, "\n"
		"SBase_renameMetaIdRefs(SBase self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given meta identifier attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object 'meta' identifiers are of the XML data type ID; the\n"
		"SBML object attribute itself is typically named metaid.  All\n"
		"attributes that hold values referring to values of type ID are of the\n"
		"XML data type IDREF.  They are also sometimes informally referred to\n"
		"as 'metaid refs', in analogy to the SBML-defined type SIdRef.\n"
		"\n"
		"This method works by looking at all meta-identifier attribute values,\n"
		"comparing the identifiers to the value of 'oldid'.  If any matches are\n"
		"found, the matching identifiers are replaced with 'newid'.  The method\n"
		"does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "SBase_renameUnitSIdRefs", _wrap_SBase_renameUnitSIdRefs, METH_VARARGS, "\n"
		"SBase_renameUnitSIdRefs(SBase self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "SBase_replaceSIDWithFunction", _wrap_SBase_replaceSIDWithFunction, METH_VARARGS, "\n"
		"SBase_replaceSIDWithFunction(SBase self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_divideAssignmentsToSIdByFunction", _wrap_SBase_divideAssignmentsToSIdByFunction, METH_VARARGS, "\n"
		"SBase_divideAssignmentsToSIdByFunction(SBase self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_multiplyAssignmentsToSIdByFunction", _wrap_SBase_multiplyAssignmentsToSIdByFunction, METH_VARARGS, "\n"
		"SBase_multiplyAssignmentsToSIdByFunction(SBase self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_getElementFromPluginsBySId", _wrap_SBase_getElementFromPluginsBySId, METH_VARARGS, "\n"
		"SBase_getElementFromPluginsBySId(SBase self, string id) -> SBase\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_getElementFromPluginsByMetaId", _wrap_SBase_getElementFromPluginsByMetaId, METH_VARARGS, "\n"
		"SBase_getElementFromPluginsByMetaId(SBase self, string metaid) -> SBase\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_hasNonstandardIdentifierBeginningWith", _wrap_SBase_hasNonstandardIdentifierBeginningWith, METH_VARARGS, "\n"
		"SBase_hasNonstandardIdentifierBeginningWith(SBase self, string prefix) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_prependStringToAllIdentifiers", _wrap_SBase_prependStringToAllIdentifiers, METH_VARARGS, "\n"
		"SBase_prependStringToAllIdentifiers(SBase self, string prefix) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_transformIdentifiers", _wrap_SBase_transformIdentifiers, METH_VARARGS, "\n"
		"SBase_transformIdentifiers(SBase self, IdentifierTransformer idTransformer) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_getMetaId", _wrap_SBase_getMetaId, METH_O, "\n"
		"SBase_getMetaId(SBase self) -> string\n"
		"\n"
		"Returns the value of the 'metaid' attribute of this SBML object.\n"
		"\n"
		"The optional attribute named 'metaid', present on every major SBML\n"
		"component type, is for supporting metadata annotations using RDF\n"
		"(Resource Description Format).  The attribute value has the data type\n"
		"XML ID, the XML identifier type, which means each 'metaid' value must\n"
		"be globally unique within an SBML file.  The latter point is\n"
		"important, because the uniqueness criterion applies across any\n"
		"attribute with type ID anywhere in the file, not just the 'metaid'\n"
		"attribute used by SBML---something to be aware of if your application-\n"
		"specific XML content inside the 'annotation' subelement happens to use\n"
		"the XML ID type.  Although SBML itself specifies the use of XML ID\n"
		"only for the 'metaid' attribute, SBML-compatible applications should\n"
		"be careful if they use XML ID's in XML portions of a model that are\n"
		"not defined by SBML, such as in the application-specific content of\n"
		"the 'annotation' subelement.  Finally, note that LibSBML does not\n"
		"provide an explicit XML ID data type; it uses ordinary character\n"
		"strings, which is easier for applications to support.\n"
		"\n"
		"Returns the meta-identifier of this SBML object.\n"
		"\n"
		"See also isSetMetaId(), setMetaId().\n"
		"\n"
		""},
	 { "SBase_getId", _wrap_SBase_getId, METH_O, "\n"
		"SBase_getId(SBase self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this SBML object, if it has\n"
		"one,  or the 'variable' attribute of a Rule, or the 'symbol' attribute\n"
		"of an InitialAssignment.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this SBML object, or the 'variable' if the object is\n"
		"a Rule, or the 'symbol' if the object is an InitialAssignment.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, callers should use getIdAttribute()\n"
		"instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "SBase_getIdAttribute", _wrap_SBase_getIdAttribute, METH_O, "\n"
		"SBase_getIdAttribute(SBase self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this SBML object.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this SBML object, if set and valid for this level\n"
		"and version of SBML; an empty string otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, callers should use getIdAttribute()\n"
		"instead.\n"
		"\n"
		"See also setIdAttribute(), isSetIdAttribute(), unsetIdAttribute().\n"
		"\n"
		""},
	 { "SBase_getName", _wrap_SBase_getName, METH_O, "\n"
		"SBase_getName(SBase self) -> string\n"
		"\n"
		"Returns the value of the 'name' attribute of this SBML object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns the name of this SBML object, or the empty string if not set\n"
		"or unsettable.\n"
		"\n"
		"See also getIdAttribute(), isSetName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "SBase_getNotes", _wrap_SBase_getNotes, METH_VARARGS, "\n"
		"SBase_getNotes(SBase self) -> XMLNode\n"
		"SBase_getNotes(SBase self) -> XMLNode\n"
		"\n"
		"Returns the content of the 'notes' subelement of this object as a tree\n"
		"of XMLNode objects.\n"
		"\n"
		"The optional SBML element named 'notes', present on every major SBML\n"
		"component type (and in SBML Level 3, the 'message' subelement of\n"
		"Constraint), is intended as a place for storing optional information\n"
		"intended to be seen by humans.  An example use of the 'notes' element\n"
		"would be to contain formatted user comments about the model element in\n"
		"which the 'notes' element is enclosed.  Every object derived directly\n"
		"or indirectly from type SBase can have a separate value for 'notes',\n"
		"allowing users considerable freedom when adding comments to their\n"
		"models.\n"
		"\n"
		"The format of 'notes' elements conform to the definition of XHTML 1.0.\n"
		"However, the content cannot be entirely free-form; it must satisfy\n"
		"certain requirements defined in the SBML specifications for specific\n"
		"SBML Levels.  To help verify the formatting of 'notes' content,\n"
		"libSBML provides the static utility method\n"
		"SyntaxChecker.hasExpectedXHTMLSyntax(); this method implements a\n"
		"verification process that lets callers check whether the content of a\n"
		"given XMLNode object conforms to the SBML requirements for 'notes' and\n"
		"'message' structure.  Developers are urged to consult the appropriate\n"
		"SBML specification document for the Level and Version of their model\n"
		"for more in-depth explanations of using 'notes' in SBML.  The SBML\n"
		"Level 2 and 3 specifications have considerable detail about how\n"
		"'notes' element content must be structured.\n"
		"\n"
		"The 'notes' element content returned by this method will be in XML\n"
		"form, but libSBML does not provide an object model specifically for\n"
		"the content of notes.  Callers will need to traverse the XML tree\n"
		"structure using the facilities available on XMLNode and related\n"
		"objects.  For an alternative method of accessing the notes, see\n"
		"getNotesString().\n"
		"\n"
		"Returns the content of the 'notes' subelement of this SBML object as a\n"
		"tree structure composed of XMLNode objects.\n"
		"\n"
		"See also getNotesString(), isSetNotes(), setNotes(), setNotes(),\n"
		"appendNotes(), appendNotes(), unsetNotes(),\n"
		"SyntaxChecker.hasExpectedXHTMLSyntax().\n"
		"\n"
		""},
	 { "SBase_getNotesString", _wrap_SBase_getNotesString, METH_VARARGS, "\n"
		"SBase_getNotesString(SBase self) -> string\n"
		"SBase_getNotesString(SBase self) -> string\n"
		"\n"
		"Returns the content of the 'notes' subelement of this object as a\n"
		"string.\n"
		"\n"
		"The optional SBML element named 'notes', present on every major SBML\n"
		"component type (and in SBML Level 3, the 'message' subelement of\n"
		"Constraint), is intended as a place for storing optional information\n"
		"intended to be seen by humans.  An example use of the 'notes' element\n"
		"would be to contain formatted user comments about the model element in\n"
		"which the 'notes' element is enclosed.  Every object derived directly\n"
		"or indirectly from type SBase can have a separate value for 'notes',\n"
		"allowing users considerable freedom when adding comments to their\n"
		"models.\n"
		"\n"
		"The format of 'notes' elements conform to the definition of XHTML 1.0.\n"
		"However, the content cannot be entirely free-form; it must satisfy\n"
		"certain requirements defined in the SBML specifications for specific\n"
		"SBML Levels.  To help verify the formatting of 'notes' content,\n"
		"libSBML provides the static utility method\n"
		"SyntaxChecker.hasExpectedXHTMLSyntax(); this method implements a\n"
		"verification process that lets callers check whether the content of a\n"
		"given XMLNode object conforms to the SBML requirements for 'notes' and\n"
		"'message' structure.  Developers are urged to consult the appropriate\n"
		"SBML specification document for the Level and Version of their model\n"
		"for more in-depth explanations of using 'notes' in SBML.  The SBML\n"
		"Level 2 and 3 specifications have considerable detail about how\n"
		"'notes' element content must be structured.\n"
		"\n"
		"For an alternative method of accessing the notes, see getNotes(),\n"
		"which returns the content as an XMLNode tree structure.  Depending on\n"
		"an application's needs, one or the other method may be more\n"
		"convenient.\n"
		"\n"
		"Returns the content of the 'notes' subelement of this SBML object as a\n"
		"string.\n"
		"\n"
		"See also getNotes(), isSetNotes(), setNotes(), setNotes(),\n"
		"appendNotes(), appendNotes(), unsetNotes(),\n"
		"SyntaxChecker.hasExpectedXHTMLSyntax().\n"
		"\n"
		""},
	 { "SBase_getAnnotation", _wrap_SBase_getAnnotation, METH_VARARGS, "\n"
		"SBase_getAnnotation(SBase self) -> XMLNode\n"
		"SBase_getAnnotation(SBase self) -> XMLNode\n"
		"\n"
		"Returns the content of the 'annotation' subelement of this object as a\n"
		"tree of XMLNode objects.\n"
		"\n"
		"Whereas the SBML 'notes' subelement is a container for content to be\n"
		"shown directly to humans, the 'annotation' element is a container for\n"
		"optional software-generated content not meant to be shown to humans.\n"
		"Every object derived from SBase can have its own value for\n"
		"'annotation'.  The element's content type is XML type 'any', allowing\n"
		"essentially arbitrary well-formed XML data content.\n"
		"\n"
		"SBML places a few restrictions on the organization of the content of\n"
		"annotations; these are intended to help software tools read and write\n"
		"the data as well as help reduce conflicts between annotations added by\n"
		"different tools.  Please see the SBML specifications for more details.\n"
		"\n"
		"The annotations returned by this method will be in XML form.  LibSBML\n"
		"provides an object model and related interfaces for certain specific\n"
		"kinds of annotations, namely model history information and RDF\n"
		"content.  See the ModelHistory, CVTerm and RDFAnnotationParser classes\n"
		"for more information about the facilities available.\n"
		"\n"
		"Returns the annotation of this SBML object as a tree of XMLNode\n"
		"objects.\n"
		"\n"
		"See also getAnnotationString(), isSetAnnotation(), setAnnotation(),\n"
		"setAnnotation(), appendAnnotation(), appendAnnotation(),\n"
		"unsetAnnotation().\n"
		"\n"
		""},
	 { "SBase_getAnnotationString", _wrap_SBase_getAnnotationString, METH_VARARGS, "\n"
		"SBase_getAnnotationString(SBase self) -> string\n"
		"SBase_getAnnotationString(SBase self) -> string\n"
		"\n"
		"Returns the content of the 'annotation' subelement of this object as a\n"
		"character string.\n"
		"\n"
		"Whereas the SBML 'notes' subelement is a container for content to be\n"
		"shown directly to humans, the 'annotation' element is a container for\n"
		"optional software-generated content not meant to be shown to humans.\n"
		"Every object derived from SBase can have its own value for\n"
		"'annotation'.  The element's content type is XML type 'any', allowing\n"
		"essentially arbitrary well-formed XML data content.\n"
		"\n"
		"SBML places a few restrictions on the organization of the content of\n"
		"annotations; these are intended to help software tools read and write\n"
		"the data as well as help reduce conflicts between annotations added by\n"
		"different tools.  Please see the SBML specifications for more details.\n"
		"\n"
		"The annotations returned by this method will be in string form.  See\n"
		"the method getAnnotation() for a version that returns annotations in\n"
		"XML form.\n"
		"\n"
		"Returns the annotation of this SBML object as a character string.\n"
		"\n"
		"See also getAnnotation(), isSetAnnotation(), setAnnotation(),\n"
		"setAnnotation(), appendAnnotation(), appendAnnotation(),\n"
		"unsetAnnotation().\n"
		"\n"
		""},
	 { "SBase_getNamespaces", _wrap_SBase_getNamespaces, METH_O, "\n"
		"SBase_getNamespaces(SBase self) -> XMLNamespaces\n"
		"\n"
		"Returns a list of the XML Namespaces declared on the SBML document\n"
		"owning this object.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.\n"
		"\n"
		"Returns the XML Namespaces associated with this SBML object, or 'None'\n"
		"in certain very usual circumstances where a namespace is not set.\n"
		"\n"
		"See also getLevel(), getVersion().\n"
		"\n"
		""},
	 { "SBase_getSBMLDocument", _wrap_SBase_getSBMLDocument, METH_VARARGS, "\n"
		"SBase_getSBMLDocument(SBase self) -> SBMLDocument\n"
		"SBase_getSBMLDocument(SBase self) -> SBMLDocument\n"
		"\n"
		"Returns the SBMLDocument object containing this object instance.\n"
		"\n"
		"LibSBML uses the class SBMLDocument as a top-level container for\n"
		"storing SBML content and data associated with it (such as warnings and\n"
		"error messages).  An SBML model in libSBML is contained inside an\n"
		"SBMLDocument object.  SBMLDocument corresponds roughly to the class\n"
		"SBML defined in the SBML Level 3 and Level 2 specifications, but it\n"
		"does not have a direct correspondence in SBML Level 1.  (But, it is\n"
		"created by libSBML no matter whether the model is Level 1, Level 2 or\n"
		"Level 3.)\n"
		"\n"
		"This method allows the caller to obtain the SBMLDocument for the\n"
		"current object.\n"
		"\n"
		"Returns the parent SBMLDocument object of this SBML object.\n"
		"\n"
		"See also getParentSBMLObject(), getModel().\n"
		"\n"
		""},
	 { "SBase_getParentSBMLObject", _wrap_SBase_getParentSBMLObject, METH_VARARGS, "\n"
		"SBase_getParentSBMLObject(SBase self) -> SBase\n"
		"SBase_getParentSBMLObject(SBase self) -> SBase\n"
		"\n"
		"Returns the parent SBML object containing this object.\n"
		"\n"
		"This returns the immediately-containing object.  This method is\n"
		"convenient when holding an object nested inside other objects in an\n"
		"SBML model.\n"
		"\n"
		"Returns the parent SBML object of this SBML object.\n"
		"\n"
		"See also getSBMLDocument(), getModel().\n"
		"\n"
		""},
	 { "SBase_getAncestorOfType", _wrap_SBase_getAncestorOfType, METH_VARARGS, "\n"
		"SBase_getAncestorOfType(SBase self, int type, string pkgName=\"core\") -> SBase\n"
		"SBase_getAncestorOfType(SBase self, int type, string pkgName=\"core\") -> SBase\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getAncestorOfType(int type, string pkgName = 'core')\n"
		"\n"
		"Returns the first ancestor object that has the given SBML type code\n"
		"from the given package.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are known as SBML type codes.  In the Python language interface\n"
		"for libSBML, the type codes are defined as static integer constants in\n"
		"the interface class 'libsbml'.  The names of the type codes all begin\n"
		"with the characters 'SBML_.'\n"
		"\n"
		"This method searches the tree of objects that are parents of this\n"
		"object, and returns the first one that has the given SBML type code\n"
		"from  the given 'pkgName'.\n"
		"\n"
		"Parameter 'type' is the SBML type code of the object sought.\n"
		"\n"
		"Parameter 'pkgName' is (optional) the short name of an SBML Level 3\n"
		"package to which the sought-after object must belong.\n"
		"\n"
		"Returns the ancestor SBML object of this SBML object that corresponds\n"
		"to the given SBML object type code, or 'None' if no ancestor exists.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The optional argument 'pkgName' must be used for all type codes from\n"
		"SBML Level 3 packages.  Otherwise, the function will search the\n"
		"'core' namespace alone, not find any corresponding elements, and\n"
		"return  None.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getAncestorOfType(int type, string pkgName = 'core')\n"
		"\n"
		"Returns the first ancestor object that has the given SBML type code\n"
		"from the given package.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are known as SBML type codes.  In the Python language interface\n"
		"for libSBML, the type codes are defined as static integer constants in\n"
		"the interface class 'libsbml'.  The names of the type codes all begin\n"
		"with the characters 'SBML_.'\n"
		"\n"
		"This method searches the tree of objects that are parents of this\n"
		"object, and returns the first one that has the given SBML type code\n"
		"from  the given 'pkgName'.\n"
		"\n"
		"Parameter 'type' is the SBML type code of the object sought.\n"
		"\n"
		"Parameter 'pkgName' is (optional) the short name of an SBML Level 3\n"
		"package to which the sought-after object must belong.\n"
		"\n"
		"Returns the ancestor SBML object of this SBML object that corresponds\n"
		"to the given SBML object type code, or 'None' if no ancestor exists.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The optional argument 'pkgName' must be used for all type codes from\n"
		"SBML Level 3 packages.  Otherwise, the function will search the\n"
		"'core' namespace alone, not find any corresponding elements, and\n"
		"return  None.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SBase_getSBOTerm", _wrap_SBase_getSBOTerm, METH_O, "\n"
		"SBase_getSBOTerm(SBase self) -> int\n"
		"\n"
		"Returns the integer portion of the value of the 'sboTerm' attribute of\n"
		"this object.\n"
		"\n"
		"Beginning with SBML Level 2 Version 2, objects derived from SBase\n"
		"have an optional attribute named 'sboTerm' for supporting the use of\n"
		"the Systems Biology Ontology.  In SBML proper, the data type of the\n"
		"attribute is a string of the form 'SBO:NNNNNNN', where 'NNNNNNN' is a\n"
		"seven digit integer number; libSBML simplifies the representation by\n"
		"only storing the 'NNNNNNN' integer portion.  Thus, in libSBML, the\n"
		"'sboTerm' attribute on SBase has data type 'int,' and SBO identifiers\n"
		"are stored simply as integers.\n"
		"\n"
		"SBO terms are a type of optional annotation, and each different class\n"
		"of SBML object derived from SBase imposes its own requirements about\n"
		"the values permitted for 'sboTerm'. More details can be found in SBML\n"
		"specifications for Level 2 Version 2 and above.\n"
		"\n"
		"Returns the value of the 'sboTerm' attribute as an integer, or '-1' if\n"
		"the value is not set.\n"
		"\n"
		""},
	 { "SBase_getSBOTermID", _wrap_SBase_getSBOTermID, METH_O, "\n"
		"SBase_getSBOTermID(SBase self) -> string\n"
		"\n"
		"Returns the string representation of the 'sboTerm' attribute of this\n"
		"object.\n"
		"\n"
		"Beginning with SBML Level 2 Version 2, objects derived from SBase\n"
		"have an optional attribute named 'sboTerm' for supporting the use of\n"
		"the Systems Biology Ontology.  In SBML proper, the data type of the\n"
		"attribute is a string of the form 'SBO:NNNNNNN', where 'NNNNNNN' is a\n"
		"seven digit integer number; libSBML simplifies the representation by\n"
		"only storing the 'NNNNNNN' integer portion.  Thus, in libSBML, the\n"
		"'sboTerm' attribute on SBase has data type 'int,' and SBO identifiers\n"
		"are stored simply as integers.\n"
		"\n"
		"SBO terms are a type of optional annotation, and each different class\n"
		"of SBML object derived from SBase imposes its own requirements about\n"
		"the values permitted for 'sboTerm'. More details can be found in SBML\n"
		"specifications for Level 2 Version 2 and above.\n"
		"\n"
		"Returns the value of the 'sboTerm' attribute as a string (its value\n"
		"will be of the form 'SBO:NNNNNNN'), or an empty string if the value is\n"
		"not set.\n"
		"\n"
		""},
	 { "SBase_getSBOTermAsURL", _wrap_SBase_getSBOTermAsURL, METH_O, "\n"
		"SBase_getSBOTermAsURL(SBase self) -> string\n"
		"\n"
		"Returns the URL representation of the 'sboTerm' attribute of this\n"
		"object.\n"
		"\n"
		"This method returns the entire SBO identifier as a text string in the\n"
		"form http://identifiers.org/biomodels.sbo/SBO:NNNNNNN'.\n"
		"\n"
		"SBO terms are a type of optional annotation, and each different class\n"
		"of SBML object derived from SBase imposes its own requirements about\n"
		"the values permitted for 'sboTerm'. More details can be found in SBML\n"
		"specifications for Level 2 Version 2 and above.\n"
		"\n"
		"Returns the value of the 'sboTerm' attribute as an identifiers.org\n"
		"URL, or an empty string if the value is not set.\n"
		"\n"
		""},
	 { "SBase_getLine", _wrap_SBase_getLine, METH_O, "\n"
		"SBase_getLine(SBase self) -> unsigned int\n"
		"\n"
		"Returns the line number where this object first appears in the XML\n"
		"representation of the SBML document.\n"
		"\n"
		"Returns the line number of this SBML object.  If this object was\n"
		"created programmatically and not read from a file, this method will\n"
		"return the value '0.'\n"
		"\n"
		"Note: The line number for each construct in an SBML model is set upon\n"
		"reading the model.  The accuracy of the line number depends on the\n"
		"correctness of the XML representation of the model, and on the\n"
		"particular XML parser library being used.  The former limitation\n"
		"relates to the following problem: if the model is actually invalid\n"
		"XML, then the parser may not be able to interpret the data correctly\n"
		"and consequently may not be able to establish the real line number.\n"
		"The latter limitation is simply that different parsers seem to have\n"
		"their own accuracy limitations, and out of all the parsers supported\n"
		"by libSBML, none have been 100% accurate in all situations. (At this\n"
		"time, libSBML supports the use of libxml2, Expat and Xerces.)\n"
		"\n"
		"See also getColumn().\n"
		"\n"
		""},
	 { "SBase_getColumn", _wrap_SBase_getColumn, METH_O, "\n"
		"SBase_getColumn(SBase self) -> unsigned int\n"
		"\n"
		"Returns the column number where this object first appears in the XML\n"
		"representation of the SBML document.\n"
		"\n"
		"Returns the column number of this SBML object.  If this object was\n"
		"created programmatically and not read from a file, this method will\n"
		"return the value '0.'\n"
		"\n"
		"Note: The column number for each construct in an SBML model is set\n"
		"upon reading the model.  The accuracy of the column number depends on\n"
		"the correctness of the XML representation of the model, and on the\n"
		"particular XML parser library being used.  The former limitation\n"
		"relates to the following problem: if the model is actually invalid\n"
		"XML, then the parser may not be able to interpret the data correctly\n"
		"and consequently may not be able to establish the real column number.\n"
		"The latter limitation is simply that different parsers seem to have\n"
		"their own accuracy limitations, and out of all the parsers supported\n"
		"by libSBML, none have been 100% accurate in all situations. (At this\n"
		"time, libSBML supports the use of libxml2, Expat and Xerces.)\n"
		"\n"
		"See also getLine().\n"
		"\n"
		""},
	 { "SBase_getModelHistory", _wrap_SBase_getModelHistory, METH_VARARGS, "\n"
		"SBase_getModelHistory(SBase self) -> ModelHistory\n"
		"SBase_getModelHistory(SBase self) -> ModelHistory\n"
		"\n"
		"Returns the ModelHistory object, if any, attached to this object.\n"
		"\n"
		"Returns the ModelHistory object attached to this object, or 'None' if\n"
		"none exist.\n"
		"\n"
		"Note: In SBML Level 2, model history annotations were only permitted\n"
		"on the Model element.  In SBML Level 3, they are permitted on all SBML\n"
		"components derived from SBase.\n"
		"\n"
		""},
	 { "SBase_isSetMetaId", _wrap_SBase_isSetMetaId, METH_O, "\n"
		"SBase_isSetMetaId(SBase self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this object's 'metaid' attribute is set.\n"
		"\n"
		"The optional attribute named 'metaid', present on every major SBML\n"
		"component type, is for supporting metadata annotations using RDF\n"
		"(Resource Description Format).  The attribute value has the data type\n"
		"XML ID, the XML identifier type, which means each 'metaid' value must\n"
		"be globally unique within an SBML file.  The latter point is\n"
		"important, because the uniqueness criterion applies across any\n"
		"attribute with type ID anywhere in the file, not just the 'metaid'\n"
		"attribute used by SBML---something to be aware of if your application-\n"
		"specific XML content inside the 'annotation' subelement happens to use\n"
		"the XML ID type.  Although SBML itself specifies the use of XML ID\n"
		"only for the 'metaid' attribute, SBML-compatible applications should\n"
		"be careful if they use XML ID's in XML portions of a model that are\n"
		"not defined by SBML, such as in the application-specific content of\n"
		"the 'annotation' subelement.  Finally, note that LibSBML does not\n"
		"provide an explicit XML ID data type; it uses ordinary character\n"
		"strings, which is easier for applications to support.\n"
		"\n"
		"Returns 'True' if the 'metaid' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getMetaId(), setMetaId().\n"
		"\n"
		""},
	 { "SBase_isSetId", _wrap_SBase_isSetId, METH_O, "\n"
		"SBase_isSetId(SBase self) -> bool\n"
		"\n"
		"Predicate returning 'True' if a call to getId() returns a non-empty\n"
		"string.\n"
		"\n"
		"For most objects, this function will return 'True' if its 'id'\n"
		"attribute is set, and 'False' if it is not, or if the object has no\n"
		"'id' attribute at all.  However, for an EventAssignment or a Rule,\n"
		"isSetId() checks whether the 'variable' attribute is set, and for an\n"
		"InitialAssignment, it checks whether the 'symbol' attribute is set.\n"
		"Because those elements will also have an 'id' attribute in SBML Level\n"
		"3 Version 2 which isSetId() will not check, the function itself is\n"
		"deprecated, and it is recommended to use isSetIdAttribute() in all\n"
		"cases where one needs to know whether the 'id' attribute is set, and\n"
		"to use EventAssignment.isSetVariable(), Rule.isSetVariable() and\n"
		"InitialAssignment.isSetSymbol() when the status of the 'variable' or\n"
		"'symbol' attributes need to be checked.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is recommended that callers use\n"
		"isSetIdAttribute() instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),\n"
		"isSetIdAttribute().\n"
		"\n"
		""},
	 { "SBase_isSetIdAttribute", _wrap_SBase_isSetIdAttribute, METH_O, "\n"
		"SBase_isSetIdAttribute(SBase self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this object's 'id' attribute is set.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute().\n"
		"\n"
		""},
	 { "SBase_isSetName", _wrap_SBase_isSetName, METH_O, "\n"
		"SBase_isSetName(SBase self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this object's 'name' attribute is set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns 'True' if the 'name' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "SBase_isSetNotes", _wrap_SBase_isSetNotes, METH_O, "\n"
		"SBase_isSetNotes(SBase self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this object's 'notes' subelement exists\n"
		"and has content.\n"
		"\n"
		"The optional SBML element named 'notes', present on every major SBML\n"
		"component type, is intended as a place for storing optional\n"
		"information intended to be seen by humans.  An example use of the\n"
		"'notes' element would be to contain formatted user comments about the\n"
		"model element in which the 'notes' element is enclosed.  Every object\n"
		"derived directly or indirectly from type SBase can have a separate\n"
		"value for 'notes', allowing users considerable freedom when adding\n"
		"comments to their models.\n"
		"\n"
		"The format of 'notes' elements must be XHTML 1.0.  To help verify the\n"
		"formatting of 'notes' content, libSBML provides the static utility\n"
		"method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are\n"
		"urged to consult the appropriate SBML specification document for the\n"
		"Level and Version of their model for more in-depth explanations.  The\n"
		"SBML Level 2 and 3 specifications have considerable detail about how\n"
		"'notes' element content must be structured.\n"
		"\n"
		"Returns 'True' if a 'notes' subelement exists, 'False' otherwise.\n"
		"\n"
		"See also getNotes(), getNotesString(), setNotes(), setNotes(),\n"
		"appendNotes(), appendNotes(), unsetNotes(),\n"
		"SyntaxChecker.hasExpectedXHTMLSyntax().\n"
		"\n"
		""},
	 { "SBase_isSetAnnotation", _wrap_SBase_isSetAnnotation, METH_O, "\n"
		"SBase_isSetAnnotation(SBase self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this object's 'annotation' subelement\n"
		"exists and has content.\n"
		"\n"
		"Whereas the SBase 'notes' subelement is a container for content to be\n"
		"shown directly to humans, the 'annotation' element is a container for\n"
		"optional software-generated content not meant to be shown to humans.\n"
		"Every object derived from SBase can have its own value for\n"
		"'annotation'.  The element's content type is XML type 'any', allowing\n"
		"essentially arbitrary well-formed XML data content.\n"
		"\n"
		"SBML places a few restrictions on the organization of the content of\n"
		"annotations; these are intended to help software tools read and write\n"
		"the data as well as help reduce conflicts between annotations added by\n"
		"different tools.  Please see the SBML specifications for more details.\n"
		"\n"
		"Returns 'True' if a 'annotation' subelement exists, 'False' otherwise.\n"
		"\n"
		"See also getAnnotation(), getAnnotationString(), setAnnotation(),\n"
		"setAnnotation(), appendAnnotation(), appendAnnotation(),\n"
		"unsetAnnotation().\n"
		"\n"
		""},
	 { "SBase_isSetSBOTerm", _wrap_SBase_isSetSBOTerm, METH_O, "\n"
		"SBase_isSetSBOTerm(SBase self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this object's 'sboTerm' attribute is\n"
		"set.\n"
		"\n"
		"Returns 'True' if the 'sboTerm' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "SBase_setMetaId", _wrap_SBase_setMetaId, METH_VARARGS, "\n"
		"SBase_setMetaId(SBase self, string metaid) -> int\n"
		"\n"
		"Sets the value of the meta-identifier attribute of this SBML object.\n"
		"\n"
		"The optional attribute named 'metaid', present on every major SBML\n"
		"component type, is for supporting metadata annotations using RDF\n"
		"(Resource Description Format).  The attribute value has the data type\n"
		"XML ID, the XML identifier type, which means each 'metaid' value must\n"
		"be globally unique within an SBML file.  The latter point is\n"
		"important, because the uniqueness criterion applies across any\n"
		"attribute with type ID anywhere in the file, not just the 'metaid'\n"
		"attribute used by SBML---something to be aware of if your application-\n"
		"specific XML content inside the 'annotation' subelement happens to use\n"
		"the XML ID type.  Although SBML itself specifies the use of XML ID\n"
		"only for the 'metaid' attribute, SBML-compatible applications should\n"
		"be careful if they use XML ID's in XML portions of a model that are\n"
		"not defined by SBML, such as in the application-specific content of\n"
		"the 'annotation' subelement.  Finally, note that LibSBML does not\n"
		"provide an explicit XML ID data type; it uses ordinary character\n"
		"strings, which is easier for applications to support.\n"
		"\n"
		"The string 'metaid' is copied.\n"
		"\n"
		"Parameter 'metaid' is the identifier string to use as the value of the\n"
		"'metaid' attribute.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getMetaId(), isSetMetaId().\n"
		"\n"
		""},
	 { "SBase_isSetModelHistory", _wrap_SBase_isSetModelHistory, METH_O, "\n"
		"SBase_isSetModelHistory(SBase self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this object has a ModelHistory object\n"
		"attached to it.\n"
		"\n"
		"Returns 'True' if the ModelHistory of this object is set, 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: In SBML Level 2, model history annotations were only permitted\n"
		"on the Model element.  In SBML Level 3, they are permitted on all SBML\n"
		"components derived from SBase.\n"
		"\n"
		""},
	 { "SBase_setId", _wrap_SBase_setId, METH_VARARGS, "\n"
		"SBase_setId(SBase self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this SBML object.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "SBase_setIdAttribute", _wrap_SBase_setIdAttribute, METH_VARARGS, "\n"
		"SBase_setIdAttribute(SBase self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this SBML object.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "SBase_setName", _wrap_SBase_setName, METH_VARARGS, "\n"
		"SBase_setName(SBase self, string name) -> int\n"
		"\n"
		"Sets the value of the 'name' attribute of this SBML object.\n"
		"\n"
		"The string in 'name' is copied.\n"
		"\n"
		"Parameter 'name' is the new name for the SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "SBase_setAnnotation", _wrap_SBase_setAnnotation, METH_VARARGS, "\n"
		"SBase_setAnnotation(SBase self, XMLNode annotation) -> int\n"
		"SBase_setAnnotation(SBase self, string annotation) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setAnnotation(XMLNode annotation)\n"
		"\n"
		"Sets the value of the 'annotation' subelement of this SBML object.\n"
		"\n"
		"The content of 'annotation' is copied, and any previous content of\n"
		"this object's 'annotation' subelement is deleted.\n"
		"\n"
		"Whereas the SBase 'notes' subelement is a container for content to be\n"
		"shown directly to humans, the 'annotation' element is a container for\n"
		"optional software-generated content not meant to be shown to humans.\n"
		"Every object derived from SBase can have its own value for\n"
		"'annotation'.  The element's content type is XML type 'any', allowing\n"
		"essentially arbitrary well-formed XML data content.\n"
		"\n"
		"SBML places a few restrictions on the organization of the content of\n"
		"annotations; these are intended to help software tools read and write\n"
		"the data as well as help reduce conflicts between annotations added by\n"
		"different tools.  Please see the SBML specifications for more details.\n"
		"\n"
		"Call this method will result in any existing content of the\n"
		"'annotation' subelement to be discarded.  Unless you have taken steps\n"
		"to first copy and reconstitute any existing annotations into the\n"
		"'annotation' that is about to be assigned, it is likely that\n"
		"performing such wholesale replacement is unfriendly towards other\n"
		"software applications whose annotations are discarded.  An alternative\n"
		"may be to use SBase.appendAnnotation() or SBase.appendAnnotation().\n"
		"\n"
		"Parameter 'annotation' is an XML structure that is to be used as the\n"
		"new content of the 'annotation' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also getAnnotationString(), isSetAnnotation(), setAnnotation(),\n"
		"appendAnnotation(), appendAnnotation(), unsetAnnotation().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setAnnotation(string annotation)\n"
		"\n"
		"Sets the value of the 'annotation' subelement of this SBML object.\n"
		"\n"
		"The content of 'annotation' is copied, and any previous content of\n"
		"this object's 'annotation' subelement is deleted.\n"
		"\n"
		"Whereas the SBase 'notes' subelement is a container for content to be\n"
		"shown directly to humans, the 'annotation' element is a container for\n"
		"optional software-generated content not meant to be shown to humans.\n"
		"Every object derived from SBase can have its own value for\n"
		"'annotation'.  The element's content type is XML type 'any', allowing\n"
		"essentially arbitrary well-formed XML data content.\n"
		"\n"
		"SBML places a few restrictions on the organization of the content of\n"
		"annotations; these are intended to help software tools read and write\n"
		"the data as well as help reduce conflicts between annotations added by\n"
		"different tools.  Please see the SBML specifications for more details.\n"
		"\n"
		"Call this method will result in any existing content of the\n"
		"'annotation' subelement to be discarded.  Unless you have taken steps\n"
		"to first copy and reconstitute any existing annotations into the\n"
		"'annotation' that is about to be assigned, it is likely that\n"
		"performing such wholesale replacement is unfriendly towards other\n"
		"software applications whose annotations are discarded.  An alternative\n"
		"may be to use SBase.appendAnnotation() or SBase.appendAnnotation().\n"
		"\n"
		"Parameter 'annotation' is an XML string that is to be used as the\n"
		"content of the 'annotation' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getAnnotationString(), isSetAnnotation(), setAnnotation(),\n"
		"appendAnnotation(), appendAnnotation(), unsetAnnotation().\n"
		"\n"
		""},
	 { "SBase_appendAnnotation", _wrap_SBase_appendAnnotation, METH_VARARGS, "\n"
		"SBase_appendAnnotation(SBase self, XMLNode annotation) -> int\n"
		"SBase_appendAnnotation(SBase self, string annotation) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    appendAnnotation(XMLNode annotation)\n"
		"\n"
		"Appends the given 'annotation' to the 'annotation' subelement of this\n"
		"object.\n"
		"\n"
		"Whereas the SBase 'notes' subelement is a container for content to be\n"
		"shown directly to humans, the 'annotation' element is a container for\n"
		"optional software-generated content not meant to be shown to humans.\n"
		"Every object derived from SBase can have its own value for\n"
		"'annotation'.  The element's content type is XML type 'any', allowing\n"
		"essentially arbitrary well-formed XML data content.\n"
		"\n"
		"SBML places a few restrictions on the organization of the content of\n"
		"annotations; these are intended to help software tools read and write\n"
		"the data as well as help reduce conflicts between annotations added by\n"
		"different tools.  Please see the SBML specifications for more details.\n"
		"\n"
		"Unlike SBase.setAnnotation() or SBase.setAnnotation(), this method\n"
		"allows other annotations to be preserved when an application adds its\n"
		"own data.\n"
		"\n"
		"Parameter 'annotation' is an XML structure that is to be copied and\n"
		"appended to the content of the 'annotation' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE (if the parent element does not have\n"
		"the 'metaid' attribute set)\n"
		"\n"
		"* LIBSBML_DUPLICATE_ANNOTATION_NS (if the parent was already\n"
		"annotated with the annotation in question)\n"
		"\n"
		"See also getAnnotationString(), isSetAnnotation(), setAnnotation(),\n"
		"setAnnotation(), appendAnnotation(), unsetAnnotation().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    appendAnnotation(string annotation)\n"
		"\n"
		"Appends the given 'annotation' to the 'annotation' subelement of this\n"
		"object.\n"
		"\n"
		"Whereas the SBase 'notes' subelement is a container for content to be\n"
		"shown directly to humans, the 'annotation' element is a container for\n"
		"optional software-generated content not meant to be shown to humans.\n"
		"Every object derived from SBase can have its own value for\n"
		"'annotation'.  The element's content type is XML type 'any', allowing\n"
		"essentially arbitrary well-formed XML data content.\n"
		"\n"
		"SBML places a few restrictions on the organization of the content of\n"
		"annotations; these are intended to help software tools read and write\n"
		"the data as well as help reduce conflicts between annotations added by\n"
		"different tools.  Please see the SBML specifications for more details.\n"
		"\n"
		"Unlike SBase.setAnnotation() or SBase.setAnnotation(), this method\n"
		"allows other annotations to be preserved when an application adds its\n"
		"own data.\n"
		"\n"
		"Parameter 'annotation' is an XML string that is to be copied and\n"
		"appended to the content of the 'annotation' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE (if the parent element does not have\n"
		"the 'metaid' attribute set)\n"
		"\n"
		"* LIBSBML_DUPLICATE_ANNOTATION_NS (if the parent was already\n"
		"annotated with the annotation in question)\n"
		"\n"
		"See also getAnnotationString(), isSetAnnotation(), setAnnotation(),\n"
		"setAnnotation(), appendAnnotation(), unsetAnnotation().\n"
		"\n"
		""},
	 { "SBase_removeTopLevelAnnotationElement", _wrap_SBase_removeTopLevelAnnotationElement, METH_VARARGS, "\n"
		"SBase_removeTopLevelAnnotationElement(SBase self, string elementName, string elementURI=\"\", bool removeEmpty=True) -> int\n"
		"\n"
		"Removes the top-level element within the 'annotation' subelement of\n"
		"this SBML object with the given name and optional URI.\n"
		"\n"
		"SBML places a few restrictions on the organization of the content of\n"
		"annotations; these are intended to help software tools read and write\n"
		"the data as well as help reduce conflicts between annotations added by\n"
		"different tools.  Please see the SBML specifications for more details.\n"
		"\n"
		"Calling this method allows a particular annotation element to be\n"
		"removed whilst the remaining annotations remain intact.\n"
		"\n"
		"Parameter 'elementName' is a string representing the name of the top\n"
		"level annotation element that is to be removed. Parameter 'elementURI'\n"
		"is an optional string that is used to check both the name and URI of\n"
		"the top level element to be removed. Parameter 'removeEmpty' is if\n"
		"after removing of the element, the annotation is  empty, and the\n"
		"removeEmpty argument is true, the annotation node will be  deleted\n"
		"(default).\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_ANNOTATION_NAME_NOT_FOUND\n"
		"\n"
		"* LIBSBML_ANNOTATION_NS_NOT_FOUND\n"
		"\n"
		"See also replaceTopLevelAnnotationElement(),\n"
		"replaceTopLevelAnnotationElement().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SBase_replaceTopLevelAnnotationElement", _wrap_SBase_replaceTopLevelAnnotationElement, METH_VARARGS, "\n"
		"SBase_replaceTopLevelAnnotationElement(SBase self, XMLNode annotation) -> int\n"
		"SBase_replaceTopLevelAnnotationElement(SBase self, string annotation) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    replaceTopLevelAnnotationElement(XMLNode annotation)\n"
		"\n"
		"Replaces the given top-level element within the 'annotation'\n"
		"subelement of this SBML object and with the annotation element\n"
		"supplied.\n"
		"\n"
		"SBML places a few restrictions on the organization of the content of\n"
		"annotations; these are intended to help software tools read and write\n"
		"the data as well as help reduce conflicts between annotations added by\n"
		"different tools.  Please see the SBML specifications for more details.\n"
		"\n"
		"This method determines the name of the element to be replaced from the\n"
		"annotation argument. Functionally it is equivalent to calling\n"
		"removeTopLevelAnnotationElement(name) followed by calling\n"
		"appendAnnotation(annotation_with_name), with the exception that the\n"
		"placement of the annotation element remains the same.\n"
		"\n"
		"Parameter 'annotation' is XMLNode representing the replacement top\n"
		"level annotation.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"See also removeTopLevelAnnotationElement(),\n"
		"replaceTopLevelAnnotationElement().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    replaceTopLevelAnnotationElement(string annotation)\n"
		"\n"
		"Replaces the given top-level element within the 'annotation'\n"
		"subelement of this SBML object and with the annotation element\n"
		"supplied.\n"
		"\n"
		"SBML places a few restrictions on the organization of the content of\n"
		"annotations; these are intended to help software tools read and write\n"
		"the data as well as help reduce conflicts between annotations added by\n"
		"different tools.  Please see the SBML specifications for more details.\n"
		"\n"
		"This method determines the name of the element to be replaced from the\n"
		"annotation argument. Functionally it is equivalent to calling\n"
		"removeTopLevelAnnotationElement(name) followed by calling\n"
		"appendAnnotation(annotation_with_name), with the exception that the\n"
		"placement of the annotation element remains the same.\n"
		"\n"
		"Parameter 'annotation' is string representing the replacement top\n"
		"level annotation.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"See also removeTopLevelAnnotationElement(),\n"
		"replaceTopLevelAnnotationElement().\n"
		"\n"
		""},
	 { "SBase_setNotes", _wrap_SBase_setNotes, METH_VARARGS, "\n"
		"SBase_setNotes(SBase self, XMLNode notes) -> int\n"
		"SBase_setNotes(SBase self, string notes, bool addXHTMLMarkup=False) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setNotes(string notes, bool addXHTMLMarkup = false)\n"
		"\n"
		"Sets the value of the 'notes' subelement of this SBML object to a copy\n"
		"of the string 'notes'.\n"
		"\n"
		"The content of 'notes' is copied, and any existing content of this\n"
		"object's 'notes' subelement is deleted.\n"
		"\n"
		"The optional SBML element named 'notes', present on every major SBML\n"
		"component type, is intended as a place for storing optional\n"
		"information intended to be seen by humans.  An example use of the\n"
		"'notes' element would be to contain formatted user comments about the\n"
		"model element in which the 'notes' element is enclosed.  Every object\n"
		"derived directly or indirectly from type SBase can have a separate\n"
		"value for 'notes', allowing users considerable freedom when adding\n"
		"comments to their models.\n"
		"\n"
		"The format of 'notes' elements must be XHTML 1.0.  To help verify the\n"
		"formatting of 'notes' content, libSBML provides the static utility\n"
		"method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are\n"
		"urged to consult the appropriate SBML specification document for the\n"
		"Level and Version of their model for more in-depth explanations.  The\n"
		"SBML Level 2 and 3 specifications have considerable detail about how\n"
		"'notes' element content must be structured.\n"
		"\n"
		"The following code illustrates a very simple way of setting the notes\n"
		"using this method.  Here, the object being annotated is the whole SBML\n"
		"document, but that is for illustration purposes only; you could of\n"
		"course use this same approach to annotate any other SBML component.\n"
		"\n"
		"  try:\n"
		"    sbmlDoc = SBMLDocument(3, 1)\n"
		"  except ValueError:\n"
		"    print('Could not create SBMLDocument object')\n"
		"    sys.exit(1)\n"
		"\n"
		"  note = '<body xmlns='http://www.w3.org/1999/xhtml'><p>here is my note</p></body>'\n"
		"\n"
		"  status = sbmlDoc.setNotes(note)\n"
		"  if status != LIBSBML_OPERATION_SUCCESS:\n"
		"    # Do something to handle the error here.\n"
		"    print('Unable to set notes on the SBML document object')\n"
		"    sys.exit(1)\n"
		"\n"
		"Parameter 'notes' is an XML string that is to be used as the content\n"
		"of the 'notes' subelement of this object.\n"
		"\n"
		"Parameter 'addXHTMLMarkup' is a boolean indicating whether to wrap the\n"
		"contents of the 'notes' argument with XHTML paragraph (<p>) tags.\n"
		"This is appropriate when the string in 'notes' does not already\n"
		"containg the appropriate XHTML markup.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getNotesString(), isSetNotes(), setNotes(), appendNotes(),\n"
		"appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setNotes(XMLNode notes)\n"
		"\n"
		"Sets the value of the 'notes' subelement of this SBML object.\n"
		"\n"
		"The content of 'notes' is copied, and any existing content of this\n"
		"object's 'notes' subelement is deleted.\n"
		"\n"
		"The optional SBML element named 'notes', present on every major SBML\n"
		"component type, is intended as a place for storing optional\n"
		"information intended to be seen by humans.  An example use of the\n"
		"'notes' element would be to contain formatted user comments about the\n"
		"model element in which the 'notes' element is enclosed.  Every object\n"
		"derived directly or indirectly from type SBase can have a separate\n"
		"value for 'notes', allowing users considerable freedom when adding\n"
		"comments to their models.\n"
		"\n"
		"The format of 'notes' elements must be XHTML 1.0.  To help verify the\n"
		"formatting of 'notes' content, libSBML provides the static utility\n"
		"method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are\n"
		"urged to consult the appropriate SBML specification document for the\n"
		"Level and Version of their model for more in-depth explanations.  The\n"
		"SBML Level 2 and 3 specifications have considerable detail about how\n"
		"'notes' element content must be structured.\n"
		"\n"
		"Parameter 'notes' is an XML structure that is to be used as the\n"
		"content of the 'notes' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"See also getNotesString(), isSetNotes(), setNotes(), appendNotes(),\n"
		"appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax().\n"
		"\n"
		""},
	 { "SBase_appendNotes", _wrap_SBase_appendNotes, METH_VARARGS, "\n"
		"SBase_appendNotes(SBase self, XMLNode notes) -> int\n"
		"SBase_appendNotes(SBase self, string notes) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    appendNotes(string notes)\n"
		"\n"
		"Appends the given 'notes' to the 'notes' subelement of this object.\n"
		"\n"
		"The content of the parameter 'notes' is copied.\n"
		"\n"
		"The optional SBML element named 'notes', present on every major SBML\n"
		"component type, is intended as a place for storing optional\n"
		"information intended to be seen by humans.  An example use of the\n"
		"'notes' element would be to contain formatted user comments about the\n"
		"model element in which the 'notes' element is enclosed.  Every object\n"
		"derived directly or indirectly from type SBase can have a separate\n"
		"value for 'notes', allowing users considerable freedom when adding\n"
		"comments to their models.\n"
		"\n"
		"The format of 'notes' elements must be XHTML 1.0.  To help verify the\n"
		"formatting of 'notes' content, libSBML provides the static utility\n"
		"method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are\n"
		"urged to consult the appropriate SBML specification document for the\n"
		"Level and Version of their model for more in-depth explanations.  The\n"
		"SBML Level 2 and 3 specifications have considerable detail about how\n"
		"'notes' element content must be structured.\n"
		"\n"
		"Parameter 'notes' is an XML string that is to appended to the content\n"
		"of the 'notes' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getNotesString(), isSetNotes(), setNotes(), setNotes(),\n"
		"appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    appendNotes(XMLNode notes)\n"
		"\n"
		"Appends the given 'notes' to the 'notes' subelement of this object.\n"
		"\n"
		"The content of 'notes' is copied.\n"
		"\n"
		"The optional SBML element named 'notes', present on every major SBML\n"
		"component type, is intended as a place for storing optional\n"
		"information intended to be seen by humans.  An example use of the\n"
		"'notes' element would be to contain formatted user comments about the\n"
		"model element in which the 'notes' element is enclosed.  Every object\n"
		"derived directly or indirectly from type SBase can have a separate\n"
		"value for 'notes', allowing users considerable freedom when adding\n"
		"comments to their models.\n"
		"\n"
		"The format of 'notes' elements must be XHTML 1.0.  To help verify the\n"
		"formatting of 'notes' content, libSBML provides the static utility\n"
		"method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are\n"
		"urged to consult the appropriate SBML specification document for the\n"
		"Level and Version of their model for more in-depth explanations.  The\n"
		"SBML Level 2 and 3 specifications have considerable detail about how\n"
		"'notes' element content must be structured.\n"
		"\n"
		"Parameter 'notes' is an XML node structure that is to appended to the\n"
		"content of the 'notes' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getNotesString(), isSetNotes(), setNotes(), setNotes(),\n"
		"appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax().\n"
		"\n"
		""},
	 { "SBase_setModelHistory", _wrap_SBase_setModelHistory, METH_VARARGS, "\n"
		"SBase_setModelHistory(SBase self, ModelHistory history) -> int\n"
		"\n"
		"Sets the ModelHistory of this object.\n"
		"\n"
		"The content of 'history' is copied, and this object's existing model\n"
		"history content is deleted.\n"
		"\n"
		"Parameter 'history' is ModelHistory of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"Note: In SBML Level 2, model history annotations were only permitted\n"
		"on the Model element.  In SBML Level 3, they are permitted on all SBML\n"
		"components derived from SBase.\n"
		"\n"
		""},
	 { "SBase_connectToParent", _wrap_SBase_connectToParent, METH_VARARGS, "\n"
		"SBase_connectToParent(SBase self, SBase parent)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_connectToChild", _wrap_SBase_connectToChild, METH_O, "SBase_connectToChild(SBase self)"},
	 { "SBase_setSBOTerm", _wrap_SBase_setSBOTerm, METH_VARARGS, "\n"
		"SBase_setSBOTerm(SBase self, int value) -> int\n"
		"SBase_setSBOTerm(SBase self, string sboid) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setSBOTerm(int value)\n"
		"\n"
		"Sets the value of the 'sboTerm' attribute.\n"
		"\n"
		"Beginning with SBML Level 2 Version 2, objects derived from SBase\n"
		"have an optional attribute named 'sboTerm' for supporting the use of\n"
		"the Systems Biology Ontology.  In SBML proper, the data type of the\n"
		"attribute is a string of the form 'SBO:NNNNNNN', where 'NNNNNNN' is a\n"
		"seven digit integer number; libSBML simplifies the representation by\n"
		"only storing the 'NNNNNNN' integer portion.  Thus, in libSBML, the\n"
		"'sboTerm' attribute on SBase has data type 'int,' and SBO identifiers\n"
		"are stored simply as integers.\n"
		"\n"
		"SBO terms are a type of optional annotation, and each different class\n"
		"of SBML object derived from SBase imposes its own requirements about\n"
		"the values permitted for 'sboTerm'. More details can be found in SBML\n"
		"specifications for Level 2 Version 2 and above.\n"
		"\n"
		"Parameter 'value' is the NNNNNNN integer portion of the SBO\n"
		"identifier.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also setSBOTerm().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setSBOTerm(string &sboid)\n"
		"\n"
		"Sets the value of the 'sboTerm' attribute by string.\n"
		"\n"
		"Beginning with SBML Level 2 Version 2, objects derived from SBase\n"
		"have an optional attribute named 'sboTerm' for supporting the use of\n"
		"the Systems Biology Ontology.  In SBML proper, the data type of the\n"
		"attribute is a string of the form 'SBO:NNNNNNN', where 'NNNNNNN' is a\n"
		"seven digit integer number; libSBML simplifies the representation by\n"
		"only storing the 'NNNNNNN' integer portion.  Thus, in libSBML, the\n"
		"'sboTerm' attribute on SBase has data type 'int,' and SBO identifiers\n"
		"are stored simply as integers.\n"
		"\n"
		"SBO terms are a type of optional annotation, and each different class\n"
		"of SBML object derived from SBase imposes its own requirements about\n"
		"the values permitted for 'sboTerm'. More details can be found in SBML\n"
		"specifications for Level 2 Version 2 and above.\n"
		"\n"
		"Parameter 'sboid' is the SBO identifier string of the form\n"
		"'SBO:NNNNNNN'.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also setSBOTerm().\n"
		"\n"
		""},
	 { "SBase_setNamespaces", _wrap_SBase_setNamespaces, METH_VARARGS, "\n"
		"SBase_setNamespaces(SBase self, XMLNamespaces xmlns) -> int\n"
		"\n"
		"Sets the namespaces relevant of this SBML object.\n"
		"\n"
		"The content of 'xmlns' is copied, and this object's existing namespace\n"
		"content is deleted.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.\n"
		"\n"
		"Parameter 'xmlns' is the namespaces to set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "SBase_unsetMetaId", _wrap_SBase_unsetMetaId, METH_O, "\n"
		"SBase_unsetMetaId(SBase self) -> int\n"
		"\n"
		"Unsets the value of the 'metaid' attribute of this SBML object.\n"
		"\n"
		"The optional attribute named 'metaid', present on every major SBML\n"
		"component type, is for supporting metadata annotations using RDF\n"
		"(Resource Description Format).  The attribute value has the data type\n"
		"XML ID, the XML identifier type, which means each 'metaid' value must\n"
		"be globally unique within an SBML file.  The latter point is\n"
		"important, because the uniqueness criterion applies across any\n"
		"attribute with type ID anywhere in the file, not just the 'metaid'\n"
		"attribute used by SBML---something to be aware of if your application-\n"
		"specific XML content inside the 'annotation' subelement happens to use\n"
		"the XML ID type.  Although SBML itself specifies the use of XML ID\n"
		"only for the 'metaid' attribute, SBML-compatible applications should\n"
		"be careful if they use XML ID's in XML portions of a model that are\n"
		"not defined by SBML, such as in the application-specific content of\n"
		"the 'annotation' subelement.  Finally, note that LibSBML does not\n"
		"provide an explicit XML ID data type; it uses ordinary character\n"
		"strings, which is easier for applications to support.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "SBase_unsetId", _wrap_SBase_unsetId, METH_O, "\n"
		"SBase_unsetId(SBase self) -> int\n"
		"\n"
		"Unsets the value of the 'id' attribute of this SBML object.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "SBase_unsetIdAttribute", _wrap_SBase_unsetIdAttribute, METH_O, "\n"
		"SBase_unsetIdAttribute(SBase self) -> int\n"
		"\n"
		"Unsets the value of the 'id' attribute of this SBML object.\n"
		"\n"
		"Most (but not all) objects in SBML include two common attributes: 'id'\n"
		"and 'name'.  The identifier given by an object's 'id' attribute value\n"
		"is used to identify the object within the SBML model definition. Other\n"
		"objects can refer to the component using this identifier.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute().\n"
		"\n"
		""},
	 { "SBase_unsetName", _wrap_SBase_unsetName, METH_O, "\n"
		"SBase_unsetName(SBase self) -> int\n"
		"\n"
		"Unsets the value of the 'name' attribute of this SBML object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getName(), setName(), isSetName().\n"
		"\n"
		""},
	 { "SBase_unsetNotes", _wrap_SBase_unsetNotes, METH_O, "\n"
		"SBase_unsetNotes(SBase self) -> int\n"
		"\n"
		"Unsets the value of the 'notes' subelement of this SBML object.\n"
		"\n"
		"The optional SBML element named 'notes', present on every major SBML\n"
		"component type, is intended as a place for storing optional\n"
		"information intended to be seen by humans.  An example use of the\n"
		"'notes' element would be to contain formatted user comments about the\n"
		"model element in which the 'notes' element is enclosed.  Every object\n"
		"derived directly or indirectly from type SBase can have a separate\n"
		"value for 'notes', allowing users considerable freedom when adding\n"
		"comments to their models.\n"
		"\n"
		"The format of 'notes' elements must be XHTML 1.0.  To help verify the\n"
		"formatting of 'notes' content, libSBML provides the static utility\n"
		"method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are\n"
		"urged to consult the appropriate SBML specification document for the\n"
		"Level and Version of their model for more in-depth explanations.  The\n"
		"SBML Level 2 and 3 specifications have considerable detail about how\n"
		"'notes' element content must be structured.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also getNotesString(), isSetNotes(), setNotes(), setNotes(),\n"
		"appendNotes(), appendNotes(), SyntaxChecker.hasExpectedXHTMLSyntax().\n"
		"\n"
		""},
	 { "SBase_unsetAnnotation", _wrap_SBase_unsetAnnotation, METH_O, "\n"
		"SBase_unsetAnnotation(SBase self) -> int\n"
		"\n"
		"Unsets the value of the 'annotation' subelement of this SBML object.\n"
		"\n"
		"Whereas the SBase 'notes' subelement is a container for content to be\n"
		"shown directly to humans, the 'annotation' element is a container for\n"
		"optional software-generated content not meant to be shown to humans.\n"
		"Every object derived from SBase can have its own value for\n"
		"'annotation'.  The element's content type is XML type 'any', allowing\n"
		"essentially arbitrary well-formed XML data content.\n"
		"\n"
		"SBML places a few restrictions on the organization of the content of\n"
		"annotations; these are intended to help software tools read and write\n"
		"the data as well as help reduce conflicts between annotations added by\n"
		"different tools.  Please see the SBML specifications for more details.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also getAnnotation(), getAnnotationString(), isSetAnnotation(),\n"
		"setAnnotation(), setAnnotation(), appendAnnotation(),\n"
		"appendAnnotation().\n"
		"\n"
		""},
	 { "SBase_unsetSBOTerm", _wrap_SBase_unsetSBOTerm, METH_O, "\n"
		"SBase_unsetSBOTerm(SBase self) -> int\n"
		"\n"
		"Unsets the value of the 'sboTerm' attribute of this SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		""},
	 { "SBase_addCVTerm", _wrap_SBase_addCVTerm, METH_VARARGS, "\n"
		"SBase_addCVTerm(SBase self, CVTerm term, bool newBag=False) -> int\n"
		"\n"
		"Adds a copy of the given CVTerm object to this SBML object.\n"
		"\n"
		"Parameter 'term' is the CVTerm to assign.\n"
		"\n"
		"Parameter 'newBag' is if 'True,' creates a new RDF bag with the same\n"
		"identifier as a previous bag, and if 'False,' adds the term to an\n"
		"existing RDF bag with the same type of qualifier as the term being\n"
		"added.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE, if this object lacks a 'metaid'\n"
		"attribute\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"Note: Since the CV Term uses the 'metaid' attribute of the object as a\n"
		"reference, if the object has no 'metaid' attribute value set, then the\n"
		"CVTerm will not be added.\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SBase_getCVTerms", _wrap_SBase_getCVTerms, METH_VARARGS, "\n"
		"SBase_getCVTerms(SBase self) -> List\n"
		"SBase_getCVTerms(SBase self) -> List *\n"
		"\n"
		"Returns a list of CVTerm objects in the annotations of this SBML\n"
		"object.\n"
		"\n"
		"Returns the list of CVTerms for this SBML object.\n"
		"\n"
		""},
	 { "SBase_getNumCVTerms", _wrap_SBase_getNumCVTerms, METH_O, "\n"
		"SBase_getNumCVTerms(SBase self) -> unsigned int\n"
		"\n"
		"Returns the number of CVTerm objects in the annotations of this SBML\n"
		"object.\n"
		"\n"
		"Returns the number of CVTerms for this SBML object.\n"
		"\n"
		""},
	 { "SBase_getCVTerm", _wrap_SBase_getCVTerm, METH_VARARGS, "\n"
		"SBase_getCVTerm(SBase self, unsigned int n) -> CVTerm\n"
		"\n"
		"Returns the nth CVTerm in the list of CVTerms of this SBML object.\n"
		"\n"
		"Parameter 'n' is long the index of the CVTerm to retrieve.\n"
		"\n"
		"Returns the nth CVTerm in the list of CVTerms for this SBML object. If\n"
		"the index 'n' is invalid, 'None' is returned.\n"
		"\n"
		""},
	 { "SBase_unsetCVTerms", _wrap_SBase_unsetCVTerms, METH_O, "\n"
		"SBase_unsetCVTerms(SBase self) -> int\n"
		"\n"
		"Clears the list of CVTerm objects attached to this SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "SBase_unsetModelHistory", _wrap_SBase_unsetModelHistory, METH_O, "\n"
		"SBase_unsetModelHistory(SBase self) -> int\n"
		"\n"
		"Unsets the ModelHistory object attached to this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: In SBML Level 2, model history annotations were only permitted\n"
		"on the Model element.  In SBML Level 3, they are permitted on all SBML\n"
		"components derived from SBase.\n"
		"\n"
		""},
	 { "SBase_getResourceBiologicalQualifier", _wrap_SBase_getResourceBiologicalQualifier, METH_VARARGS, "\n"
		"SBase_getResourceBiologicalQualifier(SBase self, string resource) -> BiolQualifierType_t\n"
		"\n"
		"Returns the MIRIAM biological qualifier associated with the given\n"
		"resource.\n"
		"\n"
		"In MIRIAM, qualifiers are an optional means of indicating the\n"
		"relationship between a model component and its annotations.  There are\n"
		"two broad kinds of annotations: model and biological.  The latter kind\n"
		"is used to qualify the relationship between a model component and a\n"
		"biological entity which it represents.  Examples of relationships\n"
		"include 'is' and 'has part', but many others are possible.  MIRIAM\n"
		"defines numerous relationship qualifiers to enable different software\n"
		"tools to qualify biological annotations in the same standardized way.\n"
		"In libSBML, the MIRIAM controlled-vocabulary annotations on an SBML\n"
		"model element are represented using lists of CVTerm objects, and the\n"
		"the MIRIAM biological qualifiers are represented using values whose\n"
		"names begin with BQB_ in the interface class libsbml.\n"
		"\n"
		"This method searches the controlled-vocabulary annotations (i.e., the\n"
		"list of CVTerm objects) on the present object, then out of those that\n"
		"have biological qualifiers, looks for an annotation to the given\n"
		"'resource'.  If such an annotation is found, it returns the type of\n"
		"biological qualifier associated with that resource as a  value whose\n"
		"name begins with BQB_ from the interface class libsbml.\n"
		"\n"
		"Parameter 'resource' is string representing the resource; e.g.,\n"
		"'http://www.geneontology.org/#GO:0005892'.\n"
		"\n"
		"Returns the qualifier associated with the resource, or BQB_UNKNOWN if\n"
		"the resource does not exist.\n"
		"\n"
		"Note: The set of MIRIAM biological qualifiers grows over time,\n"
		"although relatively slowly.  The values are up to date with MIRIAM at\n"
		"the time of a given libSBML release.  The set of values in list of\n"
		"BQB_ constants defined in libsbml may be expanded in later libSBML\n"
		"releases, to match the values defined by MIRIAM at that later time.\n"
		"\n"
		""},
	 { "SBase_getResourceModelQualifier", _wrap_SBase_getResourceModelQualifier, METH_VARARGS, "\n"
		"SBase_getResourceModelQualifier(SBase self, string resource) -> ModelQualifierType_t\n"
		"\n"
		"Returns the MIRIAM model qualifier associated with the given resource.\n"
		"\n"
		"In MIRIAM, qualifiers are an optional means of indicating the\n"
		"relationship between a model component and its annotations.  There are\n"
		"two broad kinds of annotations: model and biological.  The former kind\n"
		"is used to qualify the relationship between a model component and\n"
		"another modeling object.  An example qualifier is 'isDerivedFrom', to\n"
		"indicate that a given component of the model is derived from the\n"
		"modeling object represented by the referenced resource.  MIRIAM\n"
		"defines numerous relationship qualifiers to enable different software\n"
		"tools to qualify model annotations in the same standardized way.  In\n"
		"libSBML, the MIRIAM controlled-vocabulary annotations on an SBML model\n"
		"element are represented using lists of CVTerm objects, and the  the\n"
		"MIRIAM model qualifiers are represented using values whose names begin\n"
		"with BQM_ in the interface class libsbml.\n"
		"\n"
		"This method method searches the controlled-vocabulary annotations\n"
		"(i.e., the list of CVTerm objects) on the present object, then out of\n"
		"those that have model qualifiers, looks for an annotation to the given\n"
		"'resource'.  If such an annotation is found, it returns the type of\n"
		"type of model qualifier associated with that resource as a  value\n"
		"whose name begins with BQM_ from the interface class libsbml.\n"
		"\n"
		"Parameter 'resource' is string representing the resource; e.g.,\n"
		"'http://www.geneontology.org/#GO:0005892'.\n"
		"\n"
		"Returns the model qualifier type associated with the resource, or\n"
		"BQM_UNKNOWN if the resource does not exist.\n"
		"\n"
		"Note: The set of MIRIAM model qualifiers grows over time, although\n"
		"relatively slowly.  The values are up to date with MIRIAM at the time\n"
		"of a given libSBML release.  The set of values in list of BQM_\n"
		"constants defined in libsbml may be expanded in later libSBML\n"
		"releases, to match the values defined by MIRIAM at that later time.\n"
		"\n"
		""},
	 { "SBase_getModel", _wrap_SBase_getModel, METH_O, "\n"
		"SBase_getModel(SBase self) -> Model\n"
		"\n"
		"Returns the Model object for the SBML Document in which the current\n"
		"object is located.\n"
		"\n"
		"Returns the Model object for the SBML Document of this SBML object.\n"
		"\n"
		"See also getParentSBMLObject(), getSBMLDocument().\n"
		"\n"
		""},
	 { "SBase_getLevel", _wrap_SBase_getLevel, METH_O, "\n"
		"SBase_getLevel(SBase self) -> unsigned int\n"
		"\n"
		"Returns the SBML Level of the SBMLDocument object containing this\n"
		"object.\n"
		"\n"
		"LibSBML uses the class SBMLDocument as a top-level container for\n"
		"storing SBML content and data associated with it (such as warnings and\n"
		"error messages).  An SBML model in libSBML is contained inside an\n"
		"SBMLDocument object.  SBMLDocument corresponds roughly to the class\n"
		"SBML defined in the SBML Level 3 and Level 2 specifications, but it\n"
		"does not have a direct correspondence in SBML Level 1.  (But, it is\n"
		"created by libSBML no matter whether the model is Level 1, Level 2 or\n"
		"Level 3.)\n"
		"\n"
		"Returns the SBML level of this SBML object.\n"
		"\n"
		"See also getVersion(), getNamespaces(), getPackageVersion().\n"
		"\n"
		""},
	 { "SBase_getVersion", _wrap_SBase_getVersion, METH_O, "\n"
		"SBase_getVersion(SBase self) -> unsigned int\n"
		"\n"
		"Returns the Version within the SBML Level of the SBMLDocument object\n"
		"containing this object.\n"
		"\n"
		"LibSBML uses the class SBMLDocument as a top-level container for\n"
		"storing SBML content and data associated with it (such as warnings and\n"
		"error messages).  An SBML model in libSBML is contained inside an\n"
		"SBMLDocument object.  SBMLDocument corresponds roughly to the class\n"
		"SBML defined in the SBML Level 3 and Level 2 specifications, but it\n"
		"does not have a direct correspondence in SBML Level 1.  (But, it is\n"
		"created by libSBML no matter whether the model is Level 1, Level 2 or\n"
		"Level 3.)\n"
		"\n"
		"Returns the SBML version of this SBML object.\n"
		"\n"
		"See also getLevel(), getNamespaces().\n"
		"\n"
		""},
	 { "SBase_getPackageCoreVersion", _wrap_SBase_getPackageCoreVersion, METH_O, "\n"
		"SBase_getPackageCoreVersion(SBase self) -> unsigned int\n"
		"\n"
		"Returns the SBML Core Version within the SBML Level of the actual\n"
		"object.\n"
		"\n"
		"LibSBML uses the class SBMLDocument as a top-level container for\n"
		"storing SBML content and data associated with it (such as warnings and\n"
		"error messages).  An SBML model in libSBML is contained inside an\n"
		"SBMLDocument object.  SBMLDocument corresponds roughly to the class\n"
		"SBML defined in the SBML Level 3 and Level 2 specifications, but it\n"
		"does not have a direct correspondence in SBML Level 1.  (But, it is\n"
		"created by libSBML no matter whether the model is Level 1, Level 2 or\n"
		"Level 3.)\n"
		"\n"
		"Returns the SBML core version of this SBML object.\n"
		"\n"
		""},
	 { "SBase_getPackageVersion", _wrap_SBase_getPackageVersion, METH_O, "\n"
		"SBase_getPackageVersion(SBase self) -> unsigned int\n"
		"\n"
		"Returns the Version of the SBML Level 3 package to which this element\n"
		"belongs to.\n"
		"\n"
		"Returns the version of the SBML Level 3 package to which this element\n"
		"belongs. The value '0' will be returned if this element belongs to the\n"
		"SBML Level 3 Core package.\n"
		"\n"
		"See also getLevel(), getVersion().\n"
		"\n"
		""},
	 { "SBase_getPackageName", _wrap_SBase_getPackageName, METH_O, "\n"
		"SBase_getPackageName(SBase self) -> string\n"
		"\n"
		"Returns the name of the SBML Level 3 package in which this element is\n"
		"defined.\n"
		"\n"
		"Returns the name of the SBML package in which this element is defined.\n"
		"The string \"core\" will be returned if this element is defined in\n"
		"SBML Level 3 Core. The string \"unknown\" will be returned if this\n"
		"element is not defined in any SBML package.\n"
		"\n"
		""},
	 { "SBase_getTypeCode", _wrap_SBase_getTypeCode, METH_O, "\n"
		"SBase_getTypeCode(SBase self) -> int\n"
		"\n"
		"Returns the libSBML type code for this object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Here follow some additional general information about libSBML type\n"
		"codes:\n"
		"\n"
		"* The codes are the possible return values (integers) for the\n"
		"following functions:\n"
		"\n"
		"* SBase.getTypeCode()\n"
		"\n"
		"* ListOf.getItemTypeCode() (Compatibility note: in libSBML 5, the\n"
		"type of return values of these functions changed from an enumeration\n"
		"to an integer for extensibility in the face of different programming\n"
		"languages.)\n"
		"\n"
		"* Each package extension must define similar sets of values for\n"
		"each SBase subclass (e.g. SBMLLayoutTypeCode_t for the SBML Level 3\n"
		"Layout extension, SBMLFbcTypeCode_t for the SBML Level 3 Flux Balance\n"
		"Constraints extension, etc.).\n"
		"\n"
		"* The value of each package-specific type code can be duplicated\n"
		"between those of different packages.  (This is necessary because the\n"
		"development of libSBML extensions for different SBML packages may be\n"
		"undertaken by different developers at different times; requiring the\n"
		"developers to coordinate their use of type codes would be nettlesome\n"
		"and probably doomed to failure.)\n"
		"\n"
		"* To distinguish between the type codes of different packages,\n"
		"both the return value of SBase.getTypeCode() and\n"
		"SBase.getPackageName() must be checked.  This is particularly\n"
		"important for functions that take an SBML type code as an argument,\n"
		"such as SBase.getAncestorOfType(), which by default assumes you are\n"
		"handing it a core type, and will return 'None' if the value you give\n"
		"it is actually from a package.\n"
		"\n"
		"The following example code illustrates the combined use of\n"
		"SBase.getPackageName() and SBase.getTypeCode():\n"
		"\n"
		"  def example(item):\n"
		"    pkg_name  = item.getPackageName()\n"
		"    type_code = item.getTypeCode()\n"
		"    if pkg_name == 'core':\n"
		"      print('Got a ' + SBMLTypeCode_toString(type_code, 'core') + ' object')\n"
		"      if type_code == SBML_MODEL:\n"
		"        print('This is a very, very nice model')\n"
		"        # Do whatever the application wants to do with the model.\n"
		"      elif type_code == SBML_COMPARTMENT:\n"
		"        print('This is a very, very nice compartment')\n"
		"        # Do whatever the application wants to do with the compartment.\n"
		"      elif type_code == SBML_SPECIES:\n"
		"        print('This is a very, very nice species')\n"
		"        # Do whatever the application wants to do with the species.\n"
		"      elif ...\n"
		"        ...\n"
		"    elif pkg_name == 'layout':\n"
		"      print('Got a ' + SBMLTypeCode_toString(type_code, 'layout') + ' object')\n"
		"      if type_code == SBML_LAYOUT_POINT:\n"
		"        print('This is a very, very nice layout point')\n"
		"        # Do whatever the application wants to do with the layout point.\n"
		"      elif type_code == SBML_LAYOUT_BOUNDINGBOX:\n"
		"        print('This is a very, very nice layout bounding box')\n"
		"        # Do whatever the application wants to do with the layout bounding box.\n"
		"      elif ...\n"
		"        ...\n"
		"    elif pkg_name == 'unknown':\n"
		"      print('Something went wrong -- libSBML did not recognize the object type')\n"
		"      # Handle errors\n"
		"\n"
		"Returns the SBML object type code of this SBML object, or\n"
		"SBML_UNKNOWN (the default).  The latter is possible because subclasses\n"
		"of SBase are not required to implement this method to return a type\n"
		"code.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getPackageName(), getElementName().\n"
		"\n"
		""},
	 { "SBase_hasValidLevelVersionNamespaceCombination", _wrap_SBase_hasValidLevelVersionNamespaceCombination, METH_O, "\n"
		"SBase_hasValidLevelVersionNamespaceCombination(SBase self) -> bool\n"
		"\n"
		"Predicate returning @c true if this object's level/version and namespace\n"
		"values correspond to a valid SBML specification.\n"
		"\n"
		"The valid combinations of SBML Level, Version and Namespace as of this\n"
		"release of libSBML are the following:\n"
		"<ul>\n"
		"<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>\n"
		"<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>\n"
		"<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>\n"
		"<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>\n"
		"<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>\n"
		"<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>\n"
		"</ul>\n"
		"\n"
		"@return @c true if the level, version and namespace values of this \n"
		"SBML object correspond to a valid set of values, @c false otherwise.\n"
		"\n"
		""},
	 { "SBase_getElementName", _wrap_SBase_getElementName, METH_O, "\n"
		"SBase_getElementName(SBase self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"This is overridden by subclasses to return a string appropriate to the\n"
		"SBML component.  For example, Model defines it as returning ''model','\n"
		"CompartmentType defines it as returning ''compartmentType',' and so\n"
		"on.\n"
		"\n"
		""},
	 { "SBase_toSBML", _wrap_SBase_toSBML, METH_O, "\n"
		"SBase_toSBML(SBase self) -> char *\n"
		"\n"
		"Returns a string consisting of a partial SBML corresponding to just\n"
		"this object.\n"
		"\n"
		"Returns the partial SBML that describes this SBML object.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"This is primarily provided for testing and debugging purposes.  It may\n"
		"be removed in a future version of libSBML.\n"
		"\n"
		""},
	 { "SBase_toXMLNode", _wrap_SBase_toXMLNode, METH_O, "\n"
		"SBase_toXMLNode(SBase self) -> XMLNode\n"
		"\n"
		"Returns this element as an XMLNode.\n"
		"\n"
		"Returns this element as an XMLNode.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"This operation is computationally expensive, because the element has\n"
		"to be fully serialized to a string and then parsed into the XMLNode\n"
		"structure.  Attempting to convert a large tree structure (e.g., a\n"
		"large Model) may consume significant computer memory and time.\n"
		"\n"
		""},
	 { "SBase_getPlugin", _wrap_SBase_getPlugin, METH_VARARGS, "\n"
		"SBase_getPlugin(SBase self, string package) -> SBasePlugin\n"
		"SBase_getPlugin(SBase self, string package) -> SBasePlugin\n"
		"SBase_getPlugin(SBase self, unsigned int n) -> SBasePlugin\n"
		"SBase_getPlugin(SBase self, unsigned int n) -> SBasePlugin\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getPlugin(long n)\n"
		"\n"
		"Returns the nth plug-in object (extension interface) for an SBML Level\n"
		"3 package extension. The returned plug-in will be the appropriate type\n"
		"of plugin requested: calling Model.getPlugin() will return an\n"
		"FbcModelPlugin; calling Parameter.getPlugin() will return\n"
		"CompSBasePlugin, etc.\n"
		"\n"
		"If no such plugin exists, None is returned.\n"
		"\n"
		"SBML Level 3 consists of a Core definition that can be extended via\n"
		"optional SBML Level 3 packages.  A given model may indicate that it\n"
		"uses one or more SBML packages, and likewise, a software tool may be\n"
		"able to support one or more packages.  LibSBML does not come\n"
		"preconfigured with all possible packages included and enabled, in part\n"
		"because not all package specifications have been finalized.  To\n"
		"support the ability for software systems to enable support for the\n"
		"Level 3 packages they choose, libSBML features a plug-in mechanism.\n"
		"Each SBML Level 3 package is implemented in a separate code plug-in\n"
		"that can be enabled by the application to support working with that\n"
		"SBML package.  A given SBML model may thus contain not only objects\n"
		"defined by SBML Level 3 Core, but also objects created by libSBML\n"
		"plug-ins supporting additional Level 3 packages.\n"
		"\n"
		"Parameter 'n' is the index of the plug-in to return.\n"
		"\n"
		"Returns the nth plug-in object (the libSBML extension interface) of a\n"
		"package extension. If the index 'n' is invalid, 'None' is returned.\n"
		"\n"
		"See also getNumPlugins(), getPlugin().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getPlugin(string package)\n"
		"\n"
		"Returns a plug-in object (extension interface) for an SBML Level 3\n"
		"package extension with the given package name or URI. The returned\n"
		"plug-in will be the appropriate type of plugin requested: calling\n"
		"Model.getPlugin() will return an FbcModelPlugin; calling\n"
		"Parameter.getPlugin() will return CompSBasePlugin, etc.\n"
		"\n"
		"If no such plugin exists, None is returned.\n"
		"\n"
		"SBML Level 3 consists of a Core definition that can be extended via\n"
		"optional SBML Level 3 packages.  A given model may indicate that it\n"
		"uses one or more SBML packages, and likewise, a software tool may be\n"
		"able to support one or more packages.  LibSBML does not come\n"
		"preconfigured with all possible packages included and enabled, in part\n"
		"because not all package specifications have been finalized.  To\n"
		"support the ability for software systems to enable support for the\n"
		"Level 3 packages they choose, libSBML features a plug-in mechanism.\n"
		"Each SBML Level 3 package is implemented in a separate code plug-in\n"
		"that can be enabled by the application to support working with that\n"
		"SBML package.  A given SBML model may thus contain not only objects\n"
		"defined by SBML Level 3 Core, but also objects created by libSBML\n"
		"plug-ins supporting additional Level 3 packages.\n"
		"\n"
		"Parameter 'package' is the name or URI of the package.\n"
		"\n"
		"Returns the plug-in object (the libSBML extension interface) of a\n"
		"package extension with the given package name or URI.\n"
		"\n"
		"See also getPlugin().\n"
		"\n"
		""},
	 { "SBase_getDisabledPlugin", _wrap_SBase_getDisabledPlugin, METH_VARARGS, "\n"
		"SBase_getDisabledPlugin(SBase self, unsigned int n) -> SBasePlugin\n"
		"SBase_getDisabledPlugin(SBase self, unsigned int n) -> SBasePlugin\n"
		"\n"
		"Returns the nth disabled plug-in object (extension interface) for an\n"
		"SBML Level 3 package extension.  If no such plugin exists, None is\n"
		"returned.\n"
		"\n"
		"SBML Level 3 consists of a Core definition that can be extended via\n"
		"optional SBML Level 3 packages.  A given model may indicate that it\n"
		"uses one or more SBML packages, and likewise, a software tool may be\n"
		"able to support one or more packages.  LibSBML does not come\n"
		"preconfigured with all possible packages included and enabled, in part\n"
		"because not all package specifications have been finalized.  To\n"
		"support the ability for software systems to enable support for the\n"
		"Level 3 packages they choose, libSBML features a plug-in mechanism.\n"
		"Each SBML Level 3 package is implemented in a separate code plug-in\n"
		"that can be enabled by the application to support working with that\n"
		"SBML package.  A given SBML model may thus contain not only objects\n"
		"defined by SBML Level 3 Core, but also objects created by libSBML\n"
		"plug-ins supporting additional Level 3 packages.\n"
		"\n"
		"If a plugin is disabled, the package information it contains is no\n"
		"longer considered to be part of the SBML document for the purposes of\n"
		"searching the document or writing out the document.  However, the\n"
		"information is still retained, so if the plugin is enabled again, the\n"
		"same information will once again be available, and will be written out\n"
		"to the final model.\n"
		"\n"
		"Parameter 'n' is the index of the disabled plug-in to return.\n"
		"\n"
		"Returns the nth disabled plug-in object (the libSBML extension\n"
		"interface) of a package extension. If the index 'n' is invalid, 'None'\n"
		"is returned.\n"
		"\n"
		"See also getNumDisabledPlugins(), getPlugin().\n"
		"\n"
		""},
	 { "SBase_getNumPlugins", _wrap_SBase_getNumPlugins, METH_O, "\n"
		"SBase_getNumPlugins(SBase self) -> unsigned int\n"
		"\n"
		"Returns the number of plug-in objects (extenstion interfaces) for SBML\n"
		"Level 3 package extensions known.\n"
		"\n"
		"SBML Level 3 consists of a Core definition that can be extended via\n"
		"optional SBML Level 3 packages.  A given model may indicate that it\n"
		"uses one or more SBML packages, and likewise, a software tool may be\n"
		"able to support one or more packages.  LibSBML does not come\n"
		"preconfigured with all possible packages included and enabled, in part\n"
		"because not all package specifications have been finalized.  To\n"
		"support the ability for software systems to enable support for the\n"
		"Level 3 packages they choose, libSBML features a plug-in mechanism.\n"
		"Each SBML Level 3 package is implemented in a separate code plug-in\n"
		"that can be enabled by the application to support working with that\n"
		"SBML package.  A given SBML model may thus contain not only objects\n"
		"defined by SBML Level 3 Core, but also objects created by libSBML\n"
		"plug-ins supporting additional Level 3 packages.\n"
		"\n"
		"Returns the number of plug-in objects (extension interfaces) of\n"
		"package extensions known by this instance of libSBML.\n"
		"\n"
		"See also getPlugin().\n"
		"\n"
		""},
	 { "SBase_getNumDisabledPlugins", _wrap_SBase_getNumDisabledPlugins, METH_O, "\n"
		"SBase_getNumDisabledPlugins(SBase self) -> unsigned int\n"
		"\n"
		"Returns the number of disabled plug-in objects (extension interfaces)\n"
		"for SBML Level 3 package extensions known.\n"
		"\n"
		"SBML Level 3 consists of a Core definition that can be extended via\n"
		"optional SBML Level 3 packages.  A given model may indicate that it\n"
		"uses one or more SBML packages, and likewise, a software tool may be\n"
		"able to support one or more packages.  LibSBML does not come\n"
		"preconfigured with all possible packages included and enabled, in part\n"
		"because not all package specifications have been finalized.  To\n"
		"support the ability for software systems to enable support for the\n"
		"Level 3 packages they choose, libSBML features a plug-in mechanism.\n"
		"Each SBML Level 3 package is implemented in a separate code plug-in\n"
		"that can be enabled by the application to support working with that\n"
		"SBML package.  A given SBML model may thus contain not only objects\n"
		"defined by SBML Level 3 Core, but also objects created by libSBML\n"
		"plug-ins supporting additional Level 3 packages.\n"
		"\n"
		"If a plugin is disabled, the package information it contains is no\n"
		"longer considered to be part of the SBML document for the purposes of\n"
		"searching the document or writing out the document.  However, the\n"
		"information is still retained, so if the plugin is enabled again, the\n"
		"same information will once again be available, and will be written out\n"
		"to the final model.\n"
		"\n"
		"Returns the number of disabled plug-in objects (extension interfaces)\n"
		"of package extensions known by this instance of libSBML.\n"
		"\n"
		""},
	 { "SBase_deleteDisabledPlugins", _wrap_SBase_deleteDisabledPlugins, METH_VARARGS, "\n"
		"SBase_deleteDisabledPlugins(SBase self, bool recursive=True)\n"
		"\n"
		"Deletes all information stored in disabled plugins.  If the plugin is\n"
		"re-enabled later, it will then not have any previously-stored\n"
		"information.\n"
		"\n"
		"SBML Level 3 consists of a Core definition that can be extended via\n"
		"optional SBML Level 3 packages.  A given model may indicate that it\n"
		"uses one or more SBML packages, and likewise, a software tool may be\n"
		"able to support one or more packages.  LibSBML does not come\n"
		"preconfigured with all possible packages included and enabled, in part\n"
		"because not all package specifications have been finalized.  To\n"
		"support the ability for software systems to enable support for the\n"
		"Level 3 packages they choose, libSBML features a plug-in mechanism.\n"
		"Each SBML Level 3 package is implemented in a separate code plug-in\n"
		"that can be enabled by the application to support working with that\n"
		"SBML package.  A given SBML model may thus contain not only objects\n"
		"defined by SBML Level 3 Core, but also objects created by libSBML\n"
		"plug-ins supporting additional Level 3 packages.\n"
		"\n"
		"If a plugin is disabled, the package information it contains is no\n"
		"longer considered to be part of the SBML document for the purposes of\n"
		"searching the document or writing out the document.  However, the\n"
		"information is still retained, so if the plugin is enabled again, the\n"
		"same information will once again be available, and will be written out\n"
		"to the final model.\n"
		"\n"
		"Parameter 'recursive' is if 'True,' the disabled information will be\n"
		"deleted also from all child elements, otherwise only from this SBase\n"
		"element.\n"
		"\n"
		"See also getNumDisabledPlugins().\n"
		"\n"
		""},
	 { "SBase_enablePackage", _wrap_SBase_enablePackage, METH_VARARGS, "\n"
		"SBase_enablePackage(SBase self, string pkgURI, string pkgPrefix, bool flag) -> int\n"
		"\n"
		"Enables or disables the given SBML Level 3 package on this object.\n"
		"\n"
		"This method enables the specified package on this object and other\n"
		"objects connected by child-parent links in the same SBMLDocument\n"
		"object. This method is the converse of SBase.disablePackage().\n"
		"\n"
		"Parameter 'pkgURI' is the URI of the package.\n"
		"\n"
		"Parameter 'pkgPrefix' is the XML prefix of the package.\n"
		"\n"
		"Parameter 'flag' is whether to enable ('True)' or disable ('False)'\n"
		"the package.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_PKG_UNKNOWN\n"
		"\n"
		"* LIBSBML_PKG_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_PKG_CONFLICTED_VERSION\n"
		"\n"
		"See also disablePackage().\n"
		"\n"
		""},
	 { "SBase_disablePackage", _wrap_SBase_disablePackage, METH_VARARGS, "\n"
		"SBase_disablePackage(SBase self, string pkgURI, string pkgPrefix) -> int\n"
		"\n"
		"Disables the given SBML Level 3 package on this object.\n"
		"\n"
		"This method disables the specified package on this object and other\n"
		"objects connected by child-parent links in the same SBMLDocument\n"
		"object.\n"
		"\n"
		"An example of when this may be useful is during construction of model\n"
		"components when mixing existing and new models.  Suppose your\n"
		"application read an SBML document containing a model that used the\n"
		"SBML Hierarchical Model Composition (\"comp\") package, and extracted\n"
		"parts of that model in order to construct a new model in memory.  The\n"
		"new, in-memory model will not accept a component drawn from an other\n"
		"SBMLDocument with different package namespace declarations. You could\n"
		"reconstruct the same namespaces in the in-memory model first, but as a\n"
		"shortcut, you could also disable the package namespace on the object\n"
		"being added.  Here is a code example to help clarify this:\n"
		"\n"
		"  import sys\n"
		"  import os.path\n"
		"  from libsbml import *\n"
		"\n"
		"  # We read an SBML L3V1 model that uses the 'comp' package.\n"
		"\n"
		"  doc = readSBML('sbml-file-with-comp-elements.xml');\n"
		"  if doc.getNumErrors() > 0:\n"
		"    print('readSBML encountered errors while reading the file.')\n"
		"    doc.printErrors()\n"
		"    sys.exit(1)\n"
		"\n"
		"  # We extract one of the species from the model.\n"
		"\n"
		"  model = doc.getModel()\n"
		"  if model == None:\n"
		"    print('Unable to retrieve Model object')\n"
		"    sys.exit(1)\n"
		"\n"
		"  s1 = model.getSpecies(0)\n"
		"  if s1 == None:\n"
		"    print('Unable to retrieve Species object')\n"
		"    sys.exit(1)\n"
		"\n"
		"  # We construct a new model.\n"
		"  # This model does not use the 'comp' package.\n"
		"\n"
		"  try:\n"
		"    newDoc = SBMLDocument(3, 1)\n"
		"  except ValueError:\n"
		"    print('Could not create SBMLDocument object')\n"
		"    sys.exit(1)\n"
		"\n"
		"  newModel = newDoc.createModel()\n"
		"  if newModel == None:\n"
		"    print('Unable to create new Model object')\n"
		"    sys.exit(1)\n"
		"\n"
		"  # The following would normally fail with an error, because\n"
		"  # addSpecies() would first check that the parent of the given\n"
		"  # object has namespaces declared, and will discover that s1\n"
		"  # does but newModel does not.\n"
		"\n"
		"  #   newModel.addSpecies(s1)\n"
		"\n"
		"  # However, if we disable the 'comp' package on s1, then the\n"
		"  # call to addSpecies will work.\n"
		"\n"
		"  compNS = 'http://www.sbml.org/sbml/level3/version1/comp/version1'\n"
		"  status = s1.disablePackage(compNS, 'comp')\n"
		"  if status != LIBSBML_OPERATION_SUCCESS:\n"
		"    print('Unable to disable package.')\n"
		"    sys.exit(1)\n"
		"\n"
		"  newSpecies = newModel.addSpecies(s1)   # This will work now.\n"
		"  if newSpecies == None:\n"
		"    print('Could not add Species')       # (This will not happen,\n"
		"    sys.exit(1)                          # but always check errors.)\n"
		"\n"
		"Parameter 'pkgURI' is the URI of the package.\n"
		"\n"
		"Parameter 'pkgPrefix' is the XML prefix of the package.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_PKG_UNKNOWN\n"
		"\n"
		"* LIBSBML_PKG_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_PKG_CONFLICTED_VERSION\n"
		"\n"
		"See also enablePackage().\n"
		"\n"
		""},
	 { "SBase_enablePackageInternal", _wrap_SBase_enablePackageInternal, METH_VARARGS, "\n"
		"SBase_enablePackageInternal(SBase self, string pkgURI, string pkgPrefix, bool flag)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_isPackageURIEnabled", _wrap_SBase_isPackageURIEnabled, METH_VARARGS, "\n"
		"SBase_isPackageURIEnabled(SBase self, string pkgURI) -> bool\n"
		"\n"
		"Predicate returning 'True' if an SBML Level 3 package with the given\n"
		"URI is enabled with this object.\n"
		"\n"
		"Parameter 'pkgURI' is the URI of the package.\n"
		"\n"
		"Returns 'True' if the given package is enabled within this object,\n"
		"'False' otherwise.\n"
		"\n"
		"See also isPackageEnabled().\n"
		"\n"
		""},
	 { "SBase_isPackageEnabled", _wrap_SBase_isPackageEnabled, METH_VARARGS, "\n"
		"SBase_isPackageEnabled(SBase self, string pkgName) -> bool\n"
		"\n"
		"Predicate returning 'True' if the given SBML Level 3 package is\n"
		"enabled with this object.\n"
		"\n"
		"The search ignores the package version.\n"
		"\n"
		"Parameter 'pkgName' is the name of the package.\n"
		"\n"
		"Returns 'True' if the given package is enabled within this object,\n"
		"'False' otherwise.\n"
		"\n"
		"See also isPackageURIEnabled().\n"
		"\n"
		""},
	 { "SBase_isPkgURIEnabled", _wrap_SBase_isPkgURIEnabled, METH_VARARGS, "\n"
		"SBase_isPkgURIEnabled(SBase self, string pkgURI) -> bool\n"
		"\n"
		"Predicate returning 'True' if an SBML Level 3 package with the given\n"
		"URI is enabled with this object.\n"
		"\n"
		"Parameter 'pkgURI' is the URI of the package.\n"
		"\n"
		"Returns 'True' if the given package is enabled within this object,\n"
		"'False' otherwise.\n"
		"\n"
		"DEPRECATED. Replaced in libSBML 5.2.0 by SBase.isPackageURIEnabled().\n"
		"\n"
		"See also isPkgEnabled().\n"
		"\n"
		""},
	 { "SBase_isPkgEnabled", _wrap_SBase_isPkgEnabled, METH_VARARGS, "\n"
		"SBase_isPkgEnabled(SBase self, string pkgName) -> bool\n"
		"\n"
		"Predicate returning 'True' if the given SBML Level 3 package is\n"
		"enabled with this object.\n"
		"\n"
		"The search ignores the package version.\n"
		"\n"
		"Parameter 'pkgName' is the name of the package.\n"
		"\n"
		"Returns 'True' if the given package is enabled within this object,\n"
		"'False' otherwise.\n"
		"\n"
		"DEPRECATED. Replaced in libSBML 5.2.0 by SBase.isPackageEnabled().\n"
		"\n"
		"See also isPkgURIEnabled().\n"
		"\n"
		""},
	 { "SBase_writeExtensionElements", _wrap_SBase_writeExtensionElements, METH_VARARGS, "\n"
		"SBase_writeExtensionElements(SBase self, XMLOutputStream stream)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_read", _wrap_SBase_read, METH_VARARGS, "\n"
		"SBase_read(SBase self, XMLNode node, XMLErrorSeverityOverride_t flag=LIBSBML_OVERRIDE_DISABLED)\n"
		"SBase_read(SBase self, XMLInputStream stream)\n"
		""},
	 { "SBase_write", _wrap_SBase_write, METH_VARARGS, "\n"
		"SBase_write(SBase self, XMLOutputStream stream)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_hasRequiredAttributes", _wrap_SBase_hasRequiredAttributes, METH_O, "\n"
		"SBase_hasRequiredAttributes(SBase self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_hasRequiredElements", _wrap_SBase_hasRequiredElements, METH_O, "\n"
		"SBase_hasRequiredElements(SBase self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_checkCompatibility", _wrap_SBase_checkCompatibility, METH_VARARGS, "\n"
		"SBase_checkCompatibility(SBase self, SBase object) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_setSBMLNamespacesAndOwn", _wrap_SBase_setSBMLNamespacesAndOwn, METH_VARARGS, "\n"
		"SBase_setSBMLNamespacesAndOwn(SBase self, SBMLNamespaces disownedNs)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_getSBMLNamespaces", _wrap_SBase_getSBMLNamespaces, METH_O, "\n"
		"SBase_getSBMLNamespaces(SBase self) -> SBMLNamespaces\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_removeDuplicateAnnotations", _wrap_SBase_removeDuplicateAnnotations, METH_O, "\n"
		"SBase_removeDuplicateAnnotations(SBase self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_checkMathMLNamespace", _wrap_SBase_checkMathMLNamespace, METH_VARARGS, "\n"
		"SBase_checkMathMLNamespace(SBase self, XMLToken elem) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_getDerivedUnitDefinition", _wrap_SBase_getDerivedUnitDefinition, METH_O, "\n"
		"SBase_getDerivedUnitDefinition(SBase self) -> UnitDefinition\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_containsUndeclaredUnits", _wrap_SBase_containsUndeclaredUnits, METH_O, "\n"
		"SBase_containsUndeclaredUnits(SBase self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_removeFromParentAndDelete", _wrap_SBase_removeFromParentAndDelete, METH_O, "\n"
		"SBase_removeFromParentAndDelete(SBase self) -> int\n"
		"\n"
		"Removes this object from its parent.\n"
		"\n"
		"If the parent was storing this object as a pointer, it is deleted.  If\n"
		"not, it is simply cleared (as in ListOf objects).  This is a pure\n"
		"virtual method, as every SBase element has different parents, and\n"
		"therefore different methods of removing itself.  Will fail (and not\n"
		"delete itself) if it has no parent object.  This function is designed\n"
		"to be overridden, but for all objects whose parent is of the class\n"
		"ListOf, the default implementation will work.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "SBase_matchesSBMLNamespaces", _wrap_SBase_matchesSBMLNamespaces, METH_VARARGS, "\n"
		"SBase_matchesSBMLNamespaces(SBase self, SBase sb) -> bool\n"
		"SBase_matchesSBMLNamespaces(SBase self, SBase sb) -> bool\n"
		"\n"
		"Returns 'True' if this object's set of XML namespaces are the same as\n"
		"the given object's XML namespaces.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sb' is an object to compare with respect to namespaces.\n"
		"\n"
		"Returns boolean, 'True' if this object's collection of namespaces is\n"
		"the same as 'sb's', 'False' otherwise.\n"
		"\n"
		""},
	 { "SBase_matchesRequiredSBMLNamespacesForAddition", _wrap_SBase_matchesRequiredSBMLNamespacesForAddition, METH_VARARGS, "\n"
		"SBase_matchesRequiredSBMLNamespacesForAddition(SBase self, SBase sb) -> bool\n"
		"SBase_matchesRequiredSBMLNamespacesForAddition(SBase self, SBase sb) -> bool\n"
		"\n"
		"Returns 'True' if this object's set of XML namespaces are a subset of\n"
		"the given object's XML namespaces.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sb' is an object to compare with respect to namespaces.\n"
		"\n"
		"Returns boolean, 'True' if this object's collection of namespaces is a\n"
		"subset of 'sb's', 'False' otherwise.\n"
		"\n"
		""},
	 { "SBase_isSetUserData", _wrap_SBase_isSetUserData, METH_O, "\n"
		"SBase_isSetUserData(SBase self) -> bool\n"
		"\n"
		"Predicate returning true or false depending on whether the user data\n"
		"of this element has been set.\n"
		"\n"
		"The user data associated with an SBML object can be used by an\n"
		"application developer to attach custom information to that object in\n"
		"the model.  In case of a deep copy, this data will passed as-is.  The\n"
		"data attribute will never be interpreted by libSBML.\n"
		"\n"
		"Returns boolean, 'True' if this object's user data has been set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "SBase_unsetUserData", _wrap_SBase_unsetUserData, METH_O, "\n"
		"SBase_unsetUserData(SBase self) -> int\n"
		"\n"
		"Unsets the user data of this element.\n"
		"\n"
		"The user data associated with an SBML object can be used by an\n"
		"application developer to attach custom information to that object in\n"
		"the model.  In case of a deep copy, this data will passed as-is.  The\n"
		"data attribute will never be interpreted by libSBML.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "SBase_getURI", _wrap_SBase_getURI, METH_O, "\n"
		"SBase_getURI(SBase self) -> string\n"
		"\n"
		"Returns the namespace URI to which this element belongs to.\n"
		"\n"
		"For example, all elements that belong to SBML Level 3 Version 1 Core\n"
		"must would have the URI\n"
		"'http://www.sbml.org/sbml/level3/version1/core'; all elements that\n"
		"belong to Layout Extension Version 1 for SBML Level 3 Version 1 Core\n"
		"must would have the URI\n"
		"'http://www.sbml.org/sbml/level3/version1/layout/version1'.\n"
		"\n"
		"This function first returns the URI for this element by looking into\n"
		"the SBMLNamespaces object of the document with the its package name.\n"
		"If not found, it will then look for the namespace associated with the\n"
		"element itself.\n"
		"\n"
		"Returns the URI of this element, as a text string.\n"
		"\n"
		"See also getSBMLDocument(), getPackageName().\n"
		"\n"
		""},
	 { "SBase_getPrefix", _wrap_SBase_getPrefix, METH_O, "\n"
		"SBase_getPrefix(SBase self) -> string\n"
		"\n"
		"Returns the XML namespace prefix of this element.\n"
		"\n"
		"This reports the XML namespace prefix chosen for this class of object\n"
		"in the current SBML document.  This may be an empty string if the\n"
		"component has no explicit prefix (for instance, if it is a core SBML\n"
		"object placed in the default SBML namespace of the document).  If it\n"
		"is not empty, then it corresponds to the XML namespace prefix used set\n"
		"the object, whatever that may be in a given SBML document.\n"
		"\n"
		"Returns a text string representing the XML namespace prefix.\n"
		"\n"
		""},
	 { "SBase_hasOptionalAttributes", _wrap_SBase_hasOptionalAttributes, METH_O, "\n"
		"SBase_hasOptionalAttributes(SBase self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_hasOptionalElements", _wrap_SBase_hasOptionalElements, METH_O, "\n"
		"SBase_hasOptionalElements(SBase self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_updateSBMLNamespace", _wrap_SBase_updateSBMLNamespace, METH_VARARGS, "\n"
		"SBase_updateSBMLNamespace(SBase self, string package, unsigned int level, unsigned int version)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBase_getListOfAllElements", _wrap_SBase_getListOfAllElements, METH_VARARGS, "\n"
		"SBase_getListOfAllElements(SBase self, ElementFilter filter=None) -> SBaseList\n"
		"\n"
		"Returns an SBaseList of all child SBase objects, including those\n"
		"nested to an arbitrary depth.\n"
		"\n"
		"@return a list of all objects that are children of this object.\n"
		"\n"
		""},
	 { "SBase_getListOfAllElementsFromPlugins", _wrap_SBase_getListOfAllElementsFromPlugins, METH_VARARGS, "\n"
		"SBase_getListOfAllElementsFromPlugins(SBase self, ElementFilter filter=None) -> SBaseList\n"
		"\n"
		"Returns a List of all child SBase objects contained in SBML package\n"
		"plug-ins.\n"
		"\n"
		"@copydetails doc_what_are_plugins\n"
		"\n"
		"This method walks down the list of all SBML Level&nbsp;3 packages used\n"
		"by this object and returns all child objects defined by those packages.\n"
		"\n"
		"@return a pointer to a List of pointers to all children objects from\n"
		"plug-ins.\n"
		"\n"
		"@ifnot hasDefaultArgs @htmlinclude warn-default-args-in-docs.html @endif@~\n"
		"\n"
		""},
	 { "SBase_swigregister", SBase_swigregister, METH_O, NULL},
	 { "delete_ListOf", _wrap_delete_ListOf, METH_O, "delete_ListOf(ListOf self)"},
	 { "new_ListOf", _wrap_new_ListOf, METH_VARARGS, "\n"
		"ListOf(unsigned int level=SBML_DEFAULT_LEVEL, unsigned int version=SBML_DEFAULT_VERSION)\n"
		"ListOf(SBMLNamespaces sbmlns)\n"
		"new_ListOf(ListOf orig) -> ListOf\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOf(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOf with a given SBMLNamespaces object.\n"
		"\n"
		"Parameter 'sbmlns' is the set of SBML namespaces that this ListOf\n"
		"should contain.\n"
		"\n"
		"Note: Bare ListOf objects are impossible to add to SBML models.  The\n"
		"ListOf class is simply the base of other classes in libSBML.  Calling\n"
		"programs are not intended to create bare ListOf objects themselves.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOf(long level   = SBML_DEFAULT_LEVEL, long version =\n"
		"SBML_DEFAULT_VERSION)\n"
		"\n"
		"Creates a new ListOf object.\n"
		"\n"
		"Parameter 'level' is the SBML Level; if not assigned, defaults to the\n"
		"value of SBMLDocument.getDefaultLevel().\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level; if not\n"
		"assigned, defaults to the value of SBMLDocument.getDefaultVersion().\n"
		"\n"
		"Note: Bare ListOf objects are impossible to add to SBML models.  The\n"
		"ListOf class is simply the base of other classes in libSBML.  Calling\n"
		"programs are not intended to create bare ListOf objects themselves.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOf(ListOf orig)\n"
		"\n"
		"Copy constructor; creates a copy of this ListOf.\n"
		"\n"
		"Parameter 'orig' is the ListOf instance to copy.\n"
		"\n"
		""},
	 { "ListOf_clone", _wrap_ListOf_clone, METH_O, "\n"
		"ListOf_clone(ListOf self) -> ListOf\n"
		"\n"
		"Creates and returns a deep copy of this ListOf object.\n"
		"\n"
		"Returns the (deep) copy of this ListOf object.\n"
		"\n"
		""},
	 { "ListOf_append", _wrap_ListOf_append, METH_VARARGS, "\n"
		"ListOf_append(ListOf self, SBase item) -> int\n"
		"\n"
		"Adds an item to the end of this ListOf's list of items.\n"
		"\n"
		"This method makes a clone of the 'item' handed to it.  This means that\n"
		"when the ListOf object is destroyed, the original items will not be\n"
		"destroyed.  For a method with an alternative ownership behavior, see\n"
		"the ListOf.appendAndOwn() method.\n"
		"\n"
		"Parameter 'item' is the item to be added to the list.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"See also appendAndOwn(), appendFrom().\n"
		"\n"
		""},
	 { "ListOf_appendAndOwn", _wrap_ListOf_appendAndOwn, METH_VARARGS, "\n"
		"ListOf_appendAndOwn(ListOf self, SBase disownedItem) -> int\n"
		"\n"
		"Adds an item to the end of this ListOf's list of items.\n"
		"\n"
		"This method does not clone the 'disownedItem' handed to it; instead,\n"
		"it assumes ownership of it.  This means that when the ListOf is\n"
		"destroyed, the item will be destroyed along with it.  For a method\n"
		"with an alternative ownership behavior, see the ListOf.append()\n"
		"method.\n"
		"\n"
		"Parameter 'disownedItem' is the item to be added to the list. Will\n"
		"become a child of the parent list.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"See also append(), appendFrom().\n"
		"\n"
		""},
	 { "ListOf_appendFrom", _wrap_ListOf_appendFrom, METH_VARARGS, "\n"
		"ListOf_appendFrom(ListOf self, ListOf list) -> int\n"
		"\n"
		"Adds a clone of a list of items to this ListOf's list.\n"
		"\n"
		"Note that because this clones the objects handed to it, the original\n"
		"items will not be destroyed when this ListOf object is destroyed.\n"
		"\n"
		"Parameter 'list' is a list of items to be added.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"See also append(), appendAndOwn().\n"
		"\n"
		""},
	 { "ListOf_insert", _wrap_ListOf_insert, METH_VARARGS, "\n"
		"ListOf_insert(ListOf self, int location, SBase item) -> int\n"
		"\n"
		"Inserts an item at a given position in this ListOf's list of items.\n"
		"\n"
		"This variant of the method makes a clone of the 'item' handed to it.\n"
		"This means that when the ListOf is destroyed, the original 'item' will\n"
		"not be destroyed.\n"
		"\n"
		"Parameter 'location' is the location in the list where to insert the\n"
		"item. Parameter 'item' is the item to be inserted to the list.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"See also insertAndOwn().\n"
		"\n"
		""},
	 { "ListOf_insertAndOwn", _wrap_ListOf_insertAndOwn, METH_VARARGS, "\n"
		"ListOf_insertAndOwn(ListOf self, int location, SBase disownedItem) -> int\n"
		"\n"
		"Inserts an item at a given position in this ListOf's list of items.\n"
		"\n"
		"This variant of the method does not make a clone of the 'disownedItem'\n"
		"handed to it. This means that when the ListOf is destroyed, the\n"
		"original 'item' will be destroyed.\n"
		"\n"
		"Parameter 'location' is the location where to insert the item.\n"
		"Parameter 'disownedItem' is the item to be inserted to the list. Will\n"
		"become a child of the parent list.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"See also insert().\n"
		"\n"
		""},
	 { "ListOf_get", _wrap_ListOf_get, METH_VARARGS, "\n"
		"ListOf_get(ListOf self, unsigned int n) -> SBase\n"
		"ListOf_get(ListOf self, unsigned int n) -> SBase\n"
		"\n"
		"Get an item from the list.\n"
		"\n"
		"Parameter 'n' is the index number of the item to get.\n"
		"\n"
		"Returns the nth item in this ListOf items, or a null pointer if the\n"
		"index number 'n' refers to a nonexistent position in this list.\n"
		"\n"
		"See also size().\n"
		"\n"
		""},
	 { "ListOf_getElementBySId", _wrap_ListOf_getElementBySId, METH_VARARGS, "\n"
		"ListOf_getElementBySId(ListOf self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given identifier.\n"
		"\n"
		"This method searches this ListOf's list of items for SBML objects\n"
		"based on their 'id' attribute value in the model-wide SId identifier\n"
		"namespace.\n"
		"\n"
		"Parameter 'id' is string representing the id of the object to find.\n"
		"\n"
		"Returns the first element found with the given 'id', or 'None' if no\n"
		"such object is found.\n"
		"\n"
		""},
	 { "ListOf_getElementByMetaId", _wrap_ListOf_getElementByMetaId, METH_VARARGS, "\n"
		"ListOf_getElementByMetaId(ListOf self, string metaid) -> SBase\n"
		"\n"
		"Returns the first child element found with the given meta-identifier.\n"
		"\n"
		"Parameter 'metaid' is string representing the 'metaid' attribute of\n"
		"the object to find.\n"
		"\n"
		"Returns the first element found with the given 'metaid', or 'None' if\n"
		"no such object is found.\n"
		"\n"
		""},
	 { "ListOf_clear", _wrap_ListOf_clear, METH_VARARGS, "\n"
		"ListOf_clear(ListOf self, bool doDelete=True)\n"
		"\n"
		"Removes all items in this ListOf object.\n"
		"\n"
		"If parameter 'doDelete' is 'True' (default), all items in this ListOf\n"
		"object are deleted and cleared, and thus the caller doesn't have to\n"
		"delete those items.  Otherwise, all items are cleared only from this\n"
		"ListOf object; the caller is still responsible for deleting the actual\n"
		"items.  (In the latter case, callers are advised to store pointers to\n"
		"all items elsewhere before calling this function.)\n"
		"\n"
		"Parameter 'doDelete' is if 'True' (default), all items are deleted and\n"
		"cleared. Otherwise, all items are just cleared and not deleted.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "ListOf_removeFromParentAndDelete", _wrap_ListOf_removeFromParentAndDelete, METH_O, "\n"
		"ListOf_removeFromParentAndDelete(ListOf self) -> int\n"
		"\n"
		"Removes all items in this ListOf object and deletes its properties\n"
		"too.\n"
		"\n"
		"This performs a call to clear() with an argument of 'True' (thus\n"
		"removing all the child objects in the list), followed by calls to\n"
		"various libSBML unsetFoo methods to delete everything else: CVTerm\n"
		"objects, model history objects, etc.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "ListOf_remove", _wrap_ListOf_remove, METH_VARARGS, "\n"
		"ListOf_remove(ListOf self, unsigned int n) -> SBase\n"
		"\n"
		"Removes the nth item from this ListOf list of items and returns it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		""},
	 { "ListOf_size", _wrap_ListOf_size, METH_O, "\n"
		"ListOf_size(ListOf self) -> unsigned int\n"
		"\n"
		"Returns number of items in this ListOf list.\n"
		"\n"
		"Returns the number of items in this ListOf items.\n"
		"\n"
		""},
	 { "ListOf_connectToChild", _wrap_ListOf_connectToChild, METH_O, "ListOf_connectToChild(ListOf self)"},
	 { "ListOf_getTypeCode", _wrap_ListOf_getTypeCode, METH_O, "\n"
		"ListOf_getTypeCode(ListOf self) -> int\n"
		"\n"
		"Returns the libSBML type code for this object, namely, SBML_LIST_OF.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_LIST_OF (default).\n"
		"\n"
		"Note: The various ListOf classes mostly differ from each other in what\n"
		"they contain.  Hence, one must call getItemTypeCode() to fully\n"
		"determine the class of this SBML object.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getItemTypeCode(), getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOf_getItemTypeCode", _wrap_ListOf_getItemTypeCode, METH_O, "\n"
		"ListOf_getItemTypeCode(ListOf self) -> int\n"
		"\n"
		"Get the type code of the objects contained in this ListOf.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Classes that inherit from the ListOf class should override this method\n"
		"to return the SBML type code for the objects contained in this ListOf.\n"
		"If they do not, this method will return SBML_UNKNOWN\n"
		"\n"
		"Returns The ListOf base class contains no SBML objects, and therefore\n"
		"this method returns SBML_UNKNOWN.\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOf_getElementName", _wrap_ListOf_getElementName, METH_O, "\n"
		"ListOf_getElementName(ListOf self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for ListOf, is\n"
		"always ''listOf'.'\n"
		"\n"
		"Returns the XML name of this element.\n"
		"\n"
		""},
	 { "ListOf_enablePackageInternal", _wrap_ListOf_enablePackageInternal, METH_VARARGS, "\n"
		"ListOf_enablePackageInternal(ListOf self, string pkgURI, string pkgPrefix, bool flag)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ListOf_updateSBMLNamespace", _wrap_ListOf_updateSBMLNamespace, METH_VARARGS, "\n"
		"ListOf_updateSBMLNamespace(ListOf self, string package, unsigned int level, unsigned int version)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ListOf_hasOptionalElements", _wrap_ListOf_hasOptionalElements, METH_O, "\n"
		"ListOf_hasOptionalElements(ListOf self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ListOf_isExplicitlyListed", _wrap_ListOf_isExplicitlyListed, METH_O, "\n"
		"ListOf_isExplicitlyListed(ListOf self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ListOf_setExplicitlyListed", _wrap_ListOf_setExplicitlyListed, METH_VARARGS, "\n"
		"ListOf_setExplicitlyListed(ListOf self, bool value=True)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ListOf_sort", _wrap_ListOf_sort, METH_O, "\n"
		"ListOf_sort(ListOf self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ListOf___len__", _wrap_ListOf___len__, METH_O, "ListOf___len__(ListOf self) -> int"},
	 { "ListOf_swigregister", ListOf_swigregister, METH_O, NULL},
	 { "ListOf_swiginit", ListOf_swiginit, METH_VARARGS, NULL},
	 { "delete_Model", _wrap_delete_Model, METH_O, "delete_Model(Model self)"},
	 { "new_Model", _wrap_new_Model, METH_VARARGS, "\n"
		"Model(unsigned int level, unsigned int version)\n"
		"Model(SBMLNamespaces sbmlns)\n"
		"new_Model(Model orig) -> Model\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Model(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new Model using the given SBMLNamespaces object 'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Model(long level, long version)\n"
		"\n"
		"Creates a new Model using the given SBML 'level' and 'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"Model.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this Model.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Model(Model orig)\n"
		"\n"
		"Copy constructor; creates a (deep) copy of the given Model object.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "Model_clone", _wrap_Model_clone, METH_O, "\n"
		"Model_clone(Model self) -> Model\n"
		"\n"
		"Creates and returns a deep copy of this Model object.\n"
		"\n"
		"Returns the (deep) copy of this Model object.\n"
		"\n"
		""},
	 { "Model_getElementBySId", _wrap_Model_getElementBySId, METH_VARARGS, "\n"
		"Model_getElementBySId(Model self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given 'id'.\n"
		"\n"
		"This operation searches the model-wide SId identifier type namespace\n"
		"\n"
		"Parameter 'id' is string representing the id of the object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'id', or\n"
		"'None' if no such object is found.\n"
		"\n"
		""},
	 { "Model_getElementByMetaId", _wrap_Model_getElementByMetaId, METH_VARARGS, "\n"
		"Model_getElementByMetaId(Model self, string metaid) -> SBase\n"
		"\n"
		"Returns the first child element it can find with the given 'metaid'.\n"
		"\n"
		"Parameter 'metaid' is string representing the meta-identifier of the\n"
		"object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'metaid', or\n"
		"None if no such object is found.\n"
		"\n"
		""},
	 { "Model_getId", _wrap_Model_getId, METH_O, "\n"
		"Model_getId(Model self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this Model.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() function instead.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this Model.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Model_getName", _wrap_Model_getName, METH_O, "\n"
		"Model_getName(Model self) -> string\n"
		"\n"
		"Returns the value of the 'name' attribute of this Model object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns the name of this SBML object, or the empty string if not set\n"
		"or unsettable.\n"
		"\n"
		"See also getIdAttribute(), isSetName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "Model_getSubstanceUnits", _wrap_Model_getSubstanceUnits, METH_O, "\n"
		"Model_getSubstanceUnits(Model self) -> string\n"
		"\n"
		"Returns the value of the 'substanceUnits' attribute of this Model.\n"
		"\n"
		"Returns the substanceUnits of this Model.\n"
		"\n"
		"Note: The 'substanceUnits' attribute is available in SBML Level 3 but\n"
		"is not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_getTimeUnits", _wrap_Model_getTimeUnits, METH_O, "\n"
		"Model_getTimeUnits(Model self) -> string\n"
		"\n"
		"Returns the value of the 'timeUnits' attribute of this Model.\n"
		"\n"
		"Returns the timeUnits of this Model.\n"
		"\n"
		"Note: The 'timeUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_getVolumeUnits", _wrap_Model_getVolumeUnits, METH_O, "\n"
		"Model_getVolumeUnits(Model self) -> string\n"
		"\n"
		"Returns the value of the 'volumeUnits' attribute of this Model.\n"
		"\n"
		"Returns the volumeUnits of this Model.\n"
		"\n"
		"Note: The 'volumeUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_getAreaUnits", _wrap_Model_getAreaUnits, METH_O, "\n"
		"Model_getAreaUnits(Model self) -> string\n"
		"\n"
		"Returns the value of the 'areaUnits' attribute of this Model.\n"
		"\n"
		"Returns the areaUnits of this Model.\n"
		"\n"
		"Note: The 'areaUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_getLengthUnits", _wrap_Model_getLengthUnits, METH_O, "\n"
		"Model_getLengthUnits(Model self) -> string\n"
		"\n"
		"Returns the value of the 'lengthUnits' attribute of this Model.\n"
		"\n"
		"Returns the lengthUnits of this Model.\n"
		"\n"
		"Note: The 'lengthUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_getExtentUnits", _wrap_Model_getExtentUnits, METH_O, "\n"
		"Model_getExtentUnits(Model self) -> string\n"
		"\n"
		"Returns the value of the 'extentUnits' attribute of this Model.\n"
		"\n"
		"Returns the extentUnits of this Model.\n"
		"\n"
		"Note: The 'extentUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_getConversionFactor", _wrap_Model_getConversionFactor, METH_O, "\n"
		"Model_getConversionFactor(Model self) -> string\n"
		"\n"
		"Returns the value of the 'conversionFactor' attribute of this Model.\n"
		"\n"
		"Returns the conversionFactor of this Model.\n"
		"\n"
		"Note: The 'conversionFactor' attribute is available in  SBML Level 3\n"
		"but is not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_isSetId", _wrap_Model_isSetId, METH_O, "\n"
		"Model_isSetId(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Model's 'id' attribute is set.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is recommended that callers use\n"
		"isSetIdAttribute() instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),\n"
		"isSetIdAttribute().\n"
		"\n"
		""},
	 { "Model_isSetName", _wrap_Model_isSetName, METH_O, "\n"
		"Model_isSetName(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Model's 'name' attribute is set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns 'True' if the 'name' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "Model_isSetSubstanceUnits", _wrap_Model_isSetSubstanceUnits, METH_O, "\n"
		"Model_isSetSubstanceUnits(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Model's 'substanceUnits' attribute\n"
		"is set.\n"
		"\n"
		"Returns 'True' if the 'substanceUnits' attribute of this Model is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The 'substanceUnits' attribute is available in  SBML Level 3 but\n"
		"is not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_isSetTimeUnits", _wrap_Model_isSetTimeUnits, METH_O, "\n"
		"Model_isSetTimeUnits(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Model's 'timeUnits' attribute is\n"
		"set.\n"
		"\n"
		"Returns 'True' if the 'timeUnits' attribute of this Model is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The 'substanceUnits' attribute is available in  SBML Level 3 but\n"
		"is not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_isSetVolumeUnits", _wrap_Model_isSetVolumeUnits, METH_O, "\n"
		"Model_isSetVolumeUnits(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Model's 'volumeUnits' attribute is\n"
		"set.\n"
		"\n"
		"Returns 'True' if the 'volumeUnits' attribute of this Model is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The 'volumeUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_isSetAreaUnits", _wrap_Model_isSetAreaUnits, METH_O, "\n"
		"Model_isSetAreaUnits(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Model's 'areaUnits' attribute is\n"
		"set.\n"
		"\n"
		"Returns 'True' if the 'areaUnits' attribute of this Model is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The 'areaUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_isSetLengthUnits", _wrap_Model_isSetLengthUnits, METH_O, "\n"
		"Model_isSetLengthUnits(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Model's 'lengthUnits' attribute is\n"
		"set.\n"
		"\n"
		"Returns 'True' if the 'lengthUnits' attribute of this Model is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The 'lengthUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_isSetExtentUnits", _wrap_Model_isSetExtentUnits, METH_O, "\n"
		"Model_isSetExtentUnits(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Model's 'extentUnits' attribute is\n"
		"set.\n"
		"\n"
		"Returns 'True' if the 'extentUnits' attribute of this Model is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The 'extentUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_isSetConversionFactor", _wrap_Model_isSetConversionFactor, METH_O, "\n"
		"Model_isSetConversionFactor(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Model's 'conversionFactor'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'conversionFactor' attribute of this Model is\n"
		"set, 'False' otherwise.\n"
		"\n"
		"Note: The 'conversionFactor' attribute is available in  SBML Level 3\n"
		"but is not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_setId", _wrap_Model_setId, METH_VARARGS, "\n"
		"Model_setId(Model self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this Model.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Model_setName", _wrap_Model_setName, METH_VARARGS, "\n"
		"Model_setName(Model self, string name) -> int\n"
		"\n"
		"Sets the value of the 'name' attribute of this Model.\n"
		"\n"
		"The string in 'name' is copied.\n"
		"\n"
		"Parameter 'name' is the new name for the SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Model_setSubstanceUnits", _wrap_Model_setSubstanceUnits, METH_VARARGS, "\n"
		"Model_setSubstanceUnits(Model self, string units) -> int\n"
		"\n"
		"Sets the value of the 'substanceUnits' attribute of this Model.\n"
		"\n"
		"The string in 'units' is copied.\n"
		"\n"
		"Parameter 'units' is the new substanceUnits for the Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: The 'substanceUnits' attribute is available in  SBML Level 3 but\n"
		"is not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_setTimeUnits", _wrap_Model_setTimeUnits, METH_VARARGS, "\n"
		"Model_setTimeUnits(Model self, string units) -> int\n"
		"\n"
		"Sets the value of the 'timeUnits' attribute of this Model.\n"
		"\n"
		"The string in 'units' is copied.\n"
		"\n"
		"Parameter 'units' is the new timeUnits for the Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: The 'timeUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_setVolumeUnits", _wrap_Model_setVolumeUnits, METH_VARARGS, "\n"
		"Model_setVolumeUnits(Model self, string units) -> int\n"
		"\n"
		"Sets the value of the 'volumeUnits' attribute of this Model.\n"
		"\n"
		"The string in 'units' is copied.\n"
		"\n"
		"Parameter 'units' is the new volumeUnits for the Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: The 'volumeUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_setAreaUnits", _wrap_Model_setAreaUnits, METH_VARARGS, "\n"
		"Model_setAreaUnits(Model self, string units) -> int\n"
		"\n"
		"Sets the value of the 'areaUnits' attribute of this Model.\n"
		"\n"
		"The string in 'units' is copied.\n"
		"\n"
		"Parameter 'units' is the new areaUnits for the Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: The 'areaUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_setLengthUnits", _wrap_Model_setLengthUnits, METH_VARARGS, "\n"
		"Model_setLengthUnits(Model self, string units) -> int\n"
		"\n"
		"Sets the value of the 'lengthUnits' attribute of this Model.\n"
		"\n"
		"The string in 'units' is copied.\n"
		"\n"
		"Parameter 'units' is the new lengthUnits for the Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: The 'lengthUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_setExtentUnits", _wrap_Model_setExtentUnits, METH_VARARGS, "\n"
		"Model_setExtentUnits(Model self, string units) -> int\n"
		"\n"
		"Sets the value of the 'extentUnits' attribute of this Model.\n"
		"\n"
		"The string in 'units' is copied.\n"
		"\n"
		"Parameter 'units' is the new extentUnits for the Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: The 'extentUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_setConversionFactor", _wrap_Model_setConversionFactor, METH_VARARGS, "\n"
		"Model_setConversionFactor(Model self, string units) -> int\n"
		"\n"
		"Sets the value of the 'conversionFactor' attribute of this Model.\n"
		"\n"
		"The string in 'units' is copied.\n"
		"\n"
		"Parameter 'units' is the new conversionFactor for the Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: The 'conversionFactor' attribute is available in  SBML Level 3\n"
		"but is not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_unsetId", _wrap_Model_unsetId, METH_O, "\n"
		"Model_unsetId(Model self) -> int\n"
		"\n"
		"Unsets the value of the 'id' attribute of this Model.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Model_unsetName", _wrap_Model_unsetName, METH_O, "\n"
		"Model_unsetName(Model self) -> int\n"
		"\n"
		"Unsets the value of the 'name' attribute of this Model.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getName(), setName(), isSetName().\n"
		"\n"
		""},
	 { "Model_unsetSubstanceUnits", _wrap_Model_unsetSubstanceUnits, METH_O, "\n"
		"Model_unsetSubstanceUnits(Model self) -> int\n"
		"\n"
		"Unsets the value of the 'substanceUnits' attribute of this Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The 'substanceUnits' attribute is available in  SBML Level 3 but\n"
		"is not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_unsetTimeUnits", _wrap_Model_unsetTimeUnits, METH_O, "\n"
		"Model_unsetTimeUnits(Model self) -> int\n"
		"\n"
		"Unsets the value of the 'timeUnits' attribute of this Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The 'timeUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_unsetVolumeUnits", _wrap_Model_unsetVolumeUnits, METH_O, "\n"
		"Model_unsetVolumeUnits(Model self) -> int\n"
		"\n"
		"Unsets the value of the 'volumeUnits' attribute of this Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The 'volumeUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_unsetAreaUnits", _wrap_Model_unsetAreaUnits, METH_O, "\n"
		"Model_unsetAreaUnits(Model self) -> int\n"
		"\n"
		"Unsets the value of the 'areaUnits' attribute of this Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The 'areaUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_unsetLengthUnits", _wrap_Model_unsetLengthUnits, METH_O, "\n"
		"Model_unsetLengthUnits(Model self) -> int\n"
		"\n"
		"Unsets the value of the 'lengthUnits' attribute of this Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The 'lengthUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_unsetExtentUnits", _wrap_Model_unsetExtentUnits, METH_O, "\n"
		"Model_unsetExtentUnits(Model self) -> int\n"
		"\n"
		"Unsets the value of the 'extentUnits' attribute of this Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The 'extentUnits' attribute is available in  SBML Level 3 but is\n"
		"not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_unsetConversionFactor", _wrap_Model_unsetConversionFactor, METH_O, "\n"
		"Model_unsetConversionFactor(Model self) -> int\n"
		"\n"
		"Unsets the value of the 'conversionFactor' attribute of this Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The 'conversionFactor' attribute is available in  SBML Level 3\n"
		"but is not present on Model in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Model_addFunctionDefinition", _wrap_Model_addFunctionDefinition, METH_VARARGS, "\n"
		"Model_addFunctionDefinition(Model self, FunctionDefinition fd) -> int\n"
		"\n"
		"Adds a copy of the given FunctionDefinition object to this Model.\n"
		"\n"
		"Parameter 'fd' is the FunctionDefinition to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createFunctionDefinition().\n"
		"\n"
		""},
	 { "Model_addUnitDefinition", _wrap_Model_addUnitDefinition, METH_VARARGS, "\n"
		"Model_addUnitDefinition(Model self, UnitDefinition ud) -> int\n"
		"\n"
		"Adds a copy of the given UnitDefinition object to this Model.\n"
		"\n"
		"Parameter 'ud' is the UnitDefinition object to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createUnitDefinition().\n"
		"\n"
		""},
	 { "Model_addCompartmentType", _wrap_Model_addCompartmentType, METH_VARARGS, "\n"
		"Model_addCompartmentType(Model self, CompartmentType ct) -> int\n"
		"\n"
		"Adds a copy of the given CompartmentType object to this Model.\n"
		"\n"
		"Parameter 'ct' is the CompartmentType object to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"Note: The CompartmentType object class is only available in SBML Level\n"
		"2 Versions 2-4.  It is not available in Level 1 nor Level 3.\n"
		"\n"
		"See also createCompartmentType().\n"
		"\n"
		""},
	 { "Model_addSpeciesType", _wrap_Model_addSpeciesType, METH_VARARGS, "\n"
		"Model_addSpeciesType(Model self, SpeciesType st) -> int\n"
		"\n"
		"Adds a copy of the given SpeciesType object to this Model.\n"
		"\n"
		"Parameter 'st' is the SpeciesType object to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"Note: The SpeciesType object class is only available in SBML Level 2\n"
		"Versions 2-4.  It is not available in Level 1 nor Level 3.\n"
		"\n"
		"See also createSpeciesType().\n"
		"\n"
		""},
	 { "Model_addCompartment", _wrap_Model_addCompartment, METH_VARARGS, "\n"
		"Model_addCompartment(Model self, Compartment c) -> int\n"
		"\n"
		"Adds a copy of the given Compartment object to this Model.\n"
		"\n"
		"Parameter 'c' is the Compartment object to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createCompartment().\n"
		"\n"
		""},
	 { "Model_addSpecies", _wrap_Model_addSpecies, METH_VARARGS, "\n"
		"Model_addSpecies(Model self, Species s) -> int\n"
		"\n"
		"Adds a copy of the given Species object to this Model.\n"
		"\n"
		"Parameter 's' is the Species object to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createSpecies().\n"
		"\n"
		""},
	 { "Model_addParameter", _wrap_Model_addParameter, METH_VARARGS, "\n"
		"Model_addParameter(Model self, Parameter p) -> int\n"
		"\n"
		"Adds a copy of the given Parameter object to this Model.\n"
		"\n"
		"Parameter 'p' is the Parameter object to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createParameter().\n"
		"\n"
		""},
	 { "Model_addInitialAssignment", _wrap_Model_addInitialAssignment, METH_VARARGS, "\n"
		"Model_addInitialAssignment(Model self, InitialAssignment ia) -> int\n"
		"\n"
		"Adds a copy of the given InitialAssignment object to this Model.\n"
		"\n"
		"Parameter 'ia' is the InitialAssignment object to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createInitialAssignment().\n"
		"\n"
		""},
	 { "Model_addRule", _wrap_Model_addRule, METH_VARARGS, "\n"
		"Model_addRule(Model self, Rule r) -> int\n"
		"\n"
		"Adds a copy of the given Rule object to this Model.\n"
		"\n"
		"Parameter 'r' is the Rule object to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createAlgebraicRule(), createAssignmentRule(),\n"
		"createRateRule().\n"
		"\n"
		""},
	 { "Model_addConstraint", _wrap_Model_addConstraint, METH_VARARGS, "\n"
		"Model_addConstraint(Model self, Constraint c) -> int\n"
		"\n"
		"Adds a copy of the given Constraint object to this Model.\n"
		"\n"
		"Parameter 'c' is the Constraint object to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createConstraint().\n"
		"\n"
		""},
	 { "Model_addReaction", _wrap_Model_addReaction, METH_VARARGS, "\n"
		"Model_addReaction(Model self, Reaction r) -> int\n"
		"\n"
		"Adds a copy of the given Reaction object to this Model.\n"
		"\n"
		"Parameter 'r' is the Reaction object to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createReaction().\n"
		"\n"
		""},
	 { "Model_addEvent", _wrap_Model_addEvent, METH_VARARGS, "\n"
		"Model_addEvent(Model self, Event e) -> int\n"
		"\n"
		"Adds a copy of the given Event object to this Model.\n"
		"\n"
		"Parameter 'e' is the Event object to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createEvent().\n"
		"\n"
		""},
	 { "Model_createFunctionDefinition", _wrap_Model_createFunctionDefinition, METH_O, "\n"
		"Model_createFunctionDefinition(Model self) -> FunctionDefinition\n"
		"\n"
		"Creates a new FunctionDefinition inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the FunctionDefinition object created.\n"
		"\n"
		"See also addFunctionDefinition().\n"
		"\n"
		""},
	 { "Model_createUnitDefinition", _wrap_Model_createUnitDefinition, METH_O, "\n"
		"Model_createUnitDefinition(Model self) -> UnitDefinition\n"
		"\n"
		"Creates a new UnitDefinition inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the UnitDefinition object created.\n"
		"\n"
		"See also addUnitDefinition().\n"
		"\n"
		""},
	 { "Model_createUnit", _wrap_Model_createUnit, METH_O, "\n"
		"Model_createUnit(Model self) -> Unit\n"
		"\n"
		"Creates a new Unit object within the last UnitDefinition object\n"
		"created in this model and returns a pointer to it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"The mechanism by which the UnitDefinition was created is not\n"
		"significant.  If a UnitDefinition object does not exist in this model,\n"
		"a new Unit is not created and 'None' is returned instead.\n"
		"\n"
		"Returns the Unit object created.\n"
		"\n"
		"See also addUnitDefinition().\n"
		"\n"
		""},
	 { "Model_createCompartmentType", _wrap_Model_createCompartmentType, METH_O, "\n"
		"Model_createCompartmentType(Model self) -> CompartmentType\n"
		"\n"
		"Creates a new CompartmentType inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the CompartmentType object created.\n"
		"\n"
		"Note: The CompartmentType object class is only available in SBML Level\n"
		"2 Versions 2-4.  It is not available in Level 1 nor Level 3.\n"
		"\n"
		"See also addCompartmentType().\n"
		"\n"
		""},
	 { "Model_createSpeciesType", _wrap_Model_createSpeciesType, METH_O, "\n"
		"Model_createSpeciesType(Model self) -> SpeciesType\n"
		"\n"
		"Creates a new SpeciesType inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the SpeciesType object created.\n"
		"\n"
		"Note: The SpeciesType object class is only available in SBML Level 2\n"
		"Versions 2-4.  It is not available in Level 1 nor Level 3.\n"
		"\n"
		"See also addSpeciesType().\n"
		"\n"
		""},
	 { "Model_createCompartment", _wrap_Model_createCompartment, METH_O, "\n"
		"Model_createCompartment(Model self) -> Compartment\n"
		"\n"
		"Creates a new Compartment inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the Compartment object created.\n"
		"\n"
		"See also addCompartment().\n"
		"\n"
		""},
	 { "Model_createSpecies", _wrap_Model_createSpecies, METH_O, "\n"
		"Model_createSpecies(Model self) -> Species\n"
		"\n"
		"Creates a new Species inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the Species object created.\n"
		"\n"
		"See also addSpecies().\n"
		"\n"
		""},
	 { "Model_createParameter", _wrap_Model_createParameter, METH_O, "\n"
		"Model_createParameter(Model self) -> Parameter\n"
		"\n"
		"Creates a new Parameter inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the Parameter object created.\n"
		"\n"
		"See also addParameter().\n"
		"\n"
		""},
	 { "Model_createInitialAssignment", _wrap_Model_createInitialAssignment, METH_O, "\n"
		"Model_createInitialAssignment(Model self) -> InitialAssignment\n"
		"\n"
		"Creates a new InitialAssignment inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the InitialAssignment object created.\n"
		"\n"
		"See also addInitialAssignment().\n"
		"\n"
		""},
	 { "Model_createAlgebraicRule", _wrap_Model_createAlgebraicRule, METH_O, "\n"
		"Model_createAlgebraicRule(Model self) -> AlgebraicRule\n"
		"\n"
		"Creates a new AlgebraicRule inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the AlgebraicRule object created.\n"
		"\n"
		"See also addRule().\n"
		"\n"
		""},
	 { "Model_createAssignmentRule", _wrap_Model_createAssignmentRule, METH_O, "\n"
		"Model_createAssignmentRule(Model self) -> AssignmentRule\n"
		"\n"
		"Creates a new AssignmentRule inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the AssignmentRule object created.\n"
		"\n"
		"See also addRule().\n"
		"\n"
		""},
	 { "Model_createRateRule", _wrap_Model_createRateRule, METH_O, "\n"
		"Model_createRateRule(Model self) -> RateRule\n"
		"\n"
		"Creates a new RateRule inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the RateRule object created.\n"
		"\n"
		"See also addRule().\n"
		"\n"
		""},
	 { "Model_createConstraint", _wrap_Model_createConstraint, METH_O, "\n"
		"Model_createConstraint(Model self) -> Constraint\n"
		"\n"
		"Creates a new Constraint inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the Constraint object created.\n"
		"\n"
		"See also addConstraint().\n"
		"\n"
		""},
	 { "Model_createReaction", _wrap_Model_createReaction, METH_O, "\n"
		"Model_createReaction(Model self) -> Reaction\n"
		"\n"
		"Creates a new Reaction inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the Reaction object created.\n"
		"\n"
		"See also addReaction().\n"
		"\n"
		""},
	 { "Model_createReactant", _wrap_Model_createReactant, METH_O, "\n"
		"Model_createReactant(Model self) -> SpeciesReference\n"
		"\n"
		"Creates a new SpeciesReference object for a reactant inside the last\n"
		"Reaction object in this Model, and returns a pointer to it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"The mechanism by which the last Reaction object was created and added\n"
		"to this Model is not significant.  It could have been created in a\n"
		"variety of ways, for example using createReaction().  If a Reaction\n"
		"does not exist for this model, a new SpeciesReference is not created\n"
		"and 'None' is returned instead.\n"
		"\n"
		"Returns the SpeciesReference object created.  If a Reaction does not\n"
		"exist for this model, a new SpeciesReference is not created and 'None'\n"
		"is returned.\n"
		"\n"
		""},
	 { "Model_createProduct", _wrap_Model_createProduct, METH_O, "\n"
		"Model_createProduct(Model self) -> SpeciesReference\n"
		"\n"
		"Creates a new SpeciesReference object for a product inside the last\n"
		"Reaction object in this Model, and returns a pointer to it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"The mechanism by which the last Reaction object was created and added\n"
		"to this Model is not significant.  It could have been created in a\n"
		"variety of ways, for example using createReaction().  If a Reaction\n"
		"does not exist for this model, a new SpeciesReference is not created\n"
		"and 'None' is returned instead.\n"
		"\n"
		"Returns the SpeciesReference object created. If a Reaction does not\n"
		"exist for this model, a new SpeciesReference is not created and 'None'\n"
		"is returned.\n"
		"\n"
		""},
	 { "Model_createModifier", _wrap_Model_createModifier, METH_O, "\n"
		"Model_createModifier(Model self) -> ModifierSpeciesReference\n"
		"\n"
		"Creates a new ModifierSpeciesReference object for a modifier species\n"
		"inside the last Reaction object in this Model, and returns a pointer\n"
		"to it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"The mechanism by which the last Reaction object was created and added\n"
		"to this Model is not significant.  It could have been created in a\n"
		"variety of ways, for example using createReaction().  If a Reaction\n"
		"does not exist for this model, a new SpeciesReference is not created\n"
		"and 'None' is returned instead.\n"
		"\n"
		"Returns the SpeciesReference object created.  If a Reaction does not\n"
		"exist for this model, a new SpeciesReference is not created and 'None'\n"
		"is returned.\n"
		"\n"
		""},
	 { "Model_createKineticLaw", _wrap_Model_createKineticLaw, METH_O, "\n"
		"Model_createKineticLaw(Model self) -> KineticLaw\n"
		"\n"
		"Creates a new KineticLaw inside the last Reaction object created in\n"
		"this Model, and returns a pointer to it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"The mechanism by which the last Reaction object was created and added\n"
		"to this Model is not significant.  It could have been created in a\n"
		"variety of ways, for example using createReaction().  If a Reaction\n"
		"does not exist for this model, a new SpeciesReference is not created\n"
		"and 'None' is returned instead.\n"
		"\n"
		"Returns the KineticLaw object created.  If a Reaction does not exist\n"
		"for this model, or a Reaction does exist but already has a KineticLaw,\n"
		"a new KineticLaw is not created and 'None' is returned.\n"
		"\n"
		""},
	 { "Model_createKineticLawParameter", _wrap_Model_createKineticLawParameter, METH_O, "\n"
		"Model_createKineticLawParameter(Model self) -> Parameter\n"
		"\n"
		"Creates a new local Parameter inside the KineticLaw object of the last\n"
		"Reaction created inside this Model, and returns a pointer to it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"The last KineticLaw object in this Model could have been created in a\n"
		"variety of ways.  For example, it could have been added using\n"
		"createKineticLaw(), or it could be the result of using\n"
		"Reaction.createKineticLaw() on the Reaction object created by a\n"
		"createReaction().  If a Reaction does not exist for this model, or the\n"
		"last Reaction does not contain a KineticLaw object, a new Parameter is\n"
		"not created and 'None' is returned instead.\n"
		"\n"
		"Returns the Parameter object created.  If a Reaction does not exist\n"
		"for this model, or a KineticLaw for the Reaction does not exist, a new\n"
		"Parameter is not created and 'None' is returned.\n"
		"\n"
		""},
	 { "Model_createKineticLawLocalParameter", _wrap_Model_createKineticLawLocalParameter, METH_O, "\n"
		"Model_createKineticLawLocalParameter(Model self) -> LocalParameter\n"
		"\n"
		"Creates a new LocalParameter inside the KineticLaw object of the last\n"
		"Reaction created inside this Model, and returns a pointer to it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"The last KineticLaw object in this Model could have been created in a\n"
		"variety of ways.  For example, it could have been added using\n"
		"createKineticLaw(), or it could be the result of using\n"
		"Reaction.createKineticLaw() on the Reaction object created by a\n"
		"createReaction().  If a Reaction does not exist for this model, or the\n"
		"last Reaction does not contain a KineticLaw object, a new Parameter is\n"
		"not created and 'None' is returned instead.\n"
		"\n"
		"Returns the Parameter object created.  If a Reaction does not exist\n"
		"for this model, or a KineticLaw for the Reaction does not exist, a new\n"
		"Parameter is not created and 'None' is returned.\n"
		"\n"
		""},
	 { "Model_createEvent", _wrap_Model_createEvent, METH_O, "\n"
		"Model_createEvent(Model self) -> Event\n"
		"\n"
		"Creates a new Event inside this Model and returns it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"Returns the Event object created.\n"
		"\n"
		""},
	 { "Model_createEventAssignment", _wrap_Model_createEventAssignment, METH_O, "\n"
		"Model_createEventAssignment(Model self) -> EventAssignment\n"
		"\n"
		"Creates a new EventAssignment inside the last Event object created in\n"
		"this Model, and returns a pointer to it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"The mechanism by which the last Event object in this model was\n"
		"created is not significant.  It could have been created in a variety\n"
		"of ways, for example by using createEvent().  If no Event object\n"
		"exists in this Model object, a new EventAssignment is not created and\n"
		"'None' is returned instead.\n"
		"\n"
		"Returns the EventAssignment object created.\n"
		"\n"
		""},
	 { "Model_createTrigger", _wrap_Model_createTrigger, METH_O, "\n"
		"Model_createTrigger(Model self) -> Trigger\n"
		"\n"
		"Creates a new Trigger inside the last Event object created in this\n"
		"Model, and returns a pointer to it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"The mechanism by which the last Event object in this model was\n"
		"created is not significant.  It could have been created in a variety\n"
		"of ways, for example by using createEvent().  If no Event object\n"
		"exists in this Model object, a new EventAssignment is not created and\n"
		"'None' is returned instead.\n"
		"\n"
		"Returns the Trigger object created.\n"
		"\n"
		""},
	 { "Model_createDelay", _wrap_Model_createDelay, METH_O, "\n"
		"Model_createDelay(Model self) -> Delay\n"
		"\n"
		"Creates a new Delay inside the last Event object created in this\n"
		"Model, and returns a pointer to it.\n"
		"\n"
		"The SBML Level and Version of the enclosing Model object, as well as\n"
		"any SBML package namespaces, are used to initialize this object's\n"
		"corresponding attributes.\n"
		"\n"
		"The mechanism by which the last Event object in this model was\n"
		"created is not significant.  It could have been created in a variety\n"
		"of ways, for example by using createEvent().  If no Event object\n"
		"exists in this Model object, a new EventAssignment is not created and\n"
		"'None' is returned instead.\n"
		"\n"
		"Returns the Delay object created.\n"
		"\n"
		""},
	 { "Model_setAnnotation", _wrap_Model_setAnnotation, METH_VARARGS, "\n"
		"Model_setAnnotation(Model self, XMLNode annotation) -> int\n"
		"Model_setAnnotation(Model self, string annotation) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setAnnotation(XMLNode annotation)\n"
		"\n"
		"Sets the value of the 'annotation' subelement of this SBML object to a\n"
		"copy of 'annotation'.\n"
		"\n"
		"Any existing content of the 'annotation' subelement is discarded.\n"
		"Unless you have taken steps to first copy and reconstitute any\n"
		"existing annotations into the 'annotation' that is about to be\n"
		"assigned, it is likely that performing such wholesale replacement is\n"
		"unfriendly towards other software applications whose annotations are\n"
		"discarded.  An alternative may be to use appendAnnotation().\n"
		"\n"
		"Parameter 'annotation' is an XML structure that is to be used as the\n"
		"content of the 'annotation' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also appendAnnotation().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setAnnotation(string annotation)\n"
		"\n"
		"Sets the value of the 'annotation' subelement of this SBML object to a\n"
		"copy of 'annotation'.\n"
		"\n"
		"Any existing content of the 'annotation' subelement is discarded.\n"
		"Unless you have taken steps to first copy and reconstitute any\n"
		"existing annotations into the 'annotation' that is about to be\n"
		"assigned, it is likely that performing such wholesale replacement is\n"
		"unfriendly towards other software applications whose annotations are\n"
		"discarded.  An alternative may be to use appendAnnotation().\n"
		"\n"
		"Parameter 'annotation' is an XML string that is to be used as the\n"
		"content of the 'annotation' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also appendAnnotation().\n"
		"\n"
		""},
	 { "Model_appendAnnotation", _wrap_Model_appendAnnotation, METH_VARARGS, "\n"
		"Model_appendAnnotation(Model self, XMLNode annotation) -> int\n"
		"Model_appendAnnotation(Model self, string annotation) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    appendAnnotation(XMLNode annotation)\n"
		"\n"
		"Appends annotation content to any existing content in the 'annotation'\n"
		"subelement of this object.\n"
		"\n"
		"The content in 'annotation' is copied.  Unlike setAnnotation(), this\n"
		"method allows other annotations to be preserved when an application\n"
		"adds its own data.\n"
		"\n"
		"Parameter 'annotation' is an XML structure that is to be copied and\n"
		"appended to the content of the 'annotation' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also setAnnotation().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    appendAnnotation(string annotation)\n"
		"\n"
		"Appends annotation content to any existing content in the 'annotation'\n"
		"subelement of this object.\n"
		"\n"
		"The content in 'annotation' is copied.  Unlike setAnnotation(), this\n"
		"method allows other annotations to be preserved when an application\n"
		"adds its own data.\n"
		"\n"
		"Parameter 'annotation' is an XML string that is to be copied and\n"
		"appended to the content of the 'annotation' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also setAnnotation().\n"
		"\n"
		""},
	 { "Model_getListOfFunctionDefinitions", _wrap_Model_getListOfFunctionDefinitions, METH_VARARGS, "\n"
		"Model_getListOfFunctionDefinitions(Model self) -> ListOfFunctionDefinitions\n"
		"Model_getListOfFunctionDefinitions(Model self) -> ListOfFunctionDefinitions\n"
		"\n"
		"Get the ListOfFunctionDefinitions object in this Model.\n"
		"\n"
		"Returns the list of FunctionDefinitions for this Model.\n"
		"\n"
		""},
	 { "Model_getListOfUnitDefinitions", _wrap_Model_getListOfUnitDefinitions, METH_VARARGS, "\n"
		"Model_getListOfUnitDefinitions(Model self) -> ListOfUnitDefinitions\n"
		"Model_getListOfUnitDefinitions(Model self) -> ListOfUnitDefinitions\n"
		"\n"
		"Get the ListOfUnitDefinitions object in this Model.\n"
		"\n"
		"Returns the list of UnitDefinitions for this Model.\n"
		"\n"
		""},
	 { "Model_getListOfCompartmentTypes", _wrap_Model_getListOfCompartmentTypes, METH_VARARGS, "\n"
		"Model_getListOfCompartmentTypes(Model self) -> ListOfCompartmentTypes\n"
		"Model_getListOfCompartmentTypes(Model self) -> ListOfCompartmentTypes\n"
		"\n"
		"Get the ListOfCompartmentTypes object in this Model.\n"
		"\n"
		"Returns the list of CompartmentTypes for this Model.\n"
		"\n"
		"Note: The CompartmentType object class is only available in SBML Level\n"
		"2 Versions 2-4.  It is not available in Level 1 nor Level 3.\n"
		"\n"
		""},
	 { "Model_getListOfSpeciesTypes", _wrap_Model_getListOfSpeciesTypes, METH_VARARGS, "\n"
		"Model_getListOfSpeciesTypes(Model self) -> ListOfSpeciesTypes\n"
		"Model_getListOfSpeciesTypes(Model self) -> ListOfSpeciesTypes\n"
		"\n"
		"Get the ListOfSpeciesTypes object in this Model.\n"
		"\n"
		"Returns the list of SpeciesTypes for this Model.\n"
		"\n"
		"Note: The SpeciesType object class is only available in SBML Level 2\n"
		"Versions 2-4.  It is not available in Level 1 nor Level 3.\n"
		"\n"
		""},
	 { "Model_getListOfCompartments", _wrap_Model_getListOfCompartments, METH_VARARGS, "\n"
		"Model_getListOfCompartments(Model self) -> ListOfCompartments\n"
		"Model_getListOfCompartments(Model self) -> ListOfCompartments\n"
		"\n"
		"Get the ListOfCompartments object in this Model.\n"
		"\n"
		"Returns the list of Compartments for this Model.\n"
		"\n"
		""},
	 { "Model_getListOfSpecies", _wrap_Model_getListOfSpecies, METH_VARARGS, "\n"
		"Model_getListOfSpecies(Model self) -> ListOfSpecies\n"
		"Model_getListOfSpecies(Model self) -> ListOfSpecies\n"
		"\n"
		"Get the ListOfSpecies object in this Model.\n"
		"\n"
		"Returns the list of Species for this Model.\n"
		"\n"
		""},
	 { "Model_getListOfParameters", _wrap_Model_getListOfParameters, METH_VARARGS, "\n"
		"Model_getListOfParameters(Model self) -> ListOfParameters\n"
		"Model_getListOfParameters(Model self) -> ListOfParameters\n"
		"\n"
		"Get the ListOfParameters object in this Model.\n"
		"\n"
		"Returns the list of Parameters for this Model.\n"
		"\n"
		""},
	 { "Model_getListOfInitialAssignments", _wrap_Model_getListOfInitialAssignments, METH_VARARGS, "\n"
		"Model_getListOfInitialAssignments(Model self) -> ListOfInitialAssignments\n"
		"Model_getListOfInitialAssignments(Model self) -> ListOfInitialAssignments\n"
		"\n"
		"Get the ListOfInitialAssignments object in this Model.\n"
		"\n"
		"Returns the list of InitialAssignments for this Model.\n"
		"\n"
		""},
	 { "Model_getListOfRules", _wrap_Model_getListOfRules, METH_VARARGS, "\n"
		"Model_getListOfRules(Model self) -> ListOfRules\n"
		"Model_getListOfRules(Model self) -> ListOfRules\n"
		"\n"
		"Get the ListOfRules object in this Model.\n"
		"\n"
		"Returns the list of Rules for this Model.\n"
		"\n"
		""},
	 { "Model_getListOfConstraints", _wrap_Model_getListOfConstraints, METH_VARARGS, "\n"
		"Model_getListOfConstraints(Model self) -> ListOfConstraints\n"
		"Model_getListOfConstraints(Model self) -> ListOfConstraints\n"
		"\n"
		"Get the ListOfConstraints object in this Model.\n"
		"\n"
		"Returns the list of Constraints for this Model.\n"
		"\n"
		""},
	 { "Model_getListOfReactions", _wrap_Model_getListOfReactions, METH_VARARGS, "\n"
		"Model_getListOfReactions(Model self) -> ListOfReactions\n"
		"Model_getListOfReactions(Model self) -> ListOfReactions\n"
		"\n"
		"Get the ListOfReactions object in this Model.\n"
		"\n"
		"Returns the list of Reactions for this Model.\n"
		"\n"
		""},
	 { "Model_getListOfEvents", _wrap_Model_getListOfEvents, METH_VARARGS, "\n"
		"Model_getListOfEvents(Model self) -> ListOfEvents\n"
		"Model_getListOfEvents(Model self) -> ListOfEvents\n"
		"\n"
		"Get the ListOfEvents object in this Model.\n"
		"\n"
		"Returns the list of Events for this Model.\n"
		"\n"
		""},
	 { "Model_getFunctionDefinition", _wrap_Model_getFunctionDefinition, METH_VARARGS, "\n"
		"Model_getFunctionDefinition(Model self, unsigned int n) -> FunctionDefinition\n"
		"Model_getFunctionDefinition(Model self, unsigned int n) -> FunctionDefinition\n"
		"Model_getFunctionDefinition(Model self, string sid) -> FunctionDefinition\n"
		"Model_getFunctionDefinition(Model self, string sid) -> FunctionDefinition\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getFunctionDefinition(long n)\n"
		"\n"
		"Get the nth FunctionDefinitions object in this Model.\n"
		"\n"
		"Parameter 'n' is the index of the object to return.\n"
		"\n"
		"Returns the nth FunctionDefinition of this Model. If the index 'n' is\n"
		"invalid, 'None' is returned.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getFunctionDefinition(string sid)\n"
		"\n"
		"Get a FunctionDefinition object based on its identifier.\n"
		"\n"
		"Parameter 'sid' is the identifier to search for.\n"
		"\n"
		"Returns the FunctionDefinition in this Model with the identifier 'sid'\n"
		"or 'None' if no such FunctionDefinition exists.\n"
		"\n"
		""},
	 { "Model_getUnitDefinition", _wrap_Model_getUnitDefinition, METH_VARARGS, "\n"
		"Model_getUnitDefinition(Model self, unsigned int n) -> UnitDefinition\n"
		"Model_getUnitDefinition(Model self, unsigned int n) -> UnitDefinition\n"
		"Model_getUnitDefinition(Model self, string sid) -> UnitDefinition\n"
		"Model_getUnitDefinition(Model self, string sid) -> UnitDefinition\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getUnitDefinition(long n)\n"
		"\n"
		"Get the nth UnitDefinition object in this Model.\n"
		"\n"
		"Parameter 'n' is the index of the object to return.\n"
		"\n"
		"Returns the nth UnitDefinition of this Model. If the index 'n' is\n"
		"invalid, 'None' is returned.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getUnitDefinition(string sid)\n"
		"\n"
		"Get a UnitDefinition based on its identifier.\n"
		"\n"
		"Parameter 'sid' is the identifier to search for.\n"
		"\n"
		"Returns the UnitDefinition in this Model with the identifier 'sid' or\n"
		"'None' if no such UnitDefinition exists.\n"
		"\n"
		""},
	 { "Model_getCompartmentType", _wrap_Model_getCompartmentType, METH_VARARGS, "\n"
		"Model_getCompartmentType(Model self, unsigned int n) -> CompartmentType\n"
		"Model_getCompartmentType(Model self, unsigned int n) -> CompartmentType\n"
		"Model_getCompartmentType(Model self, string sid) -> CompartmentType\n"
		"Model_getCompartmentType(Model self, string sid) -> CompartmentType\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getCompartmentType(long n)\n"
		"\n"
		"Get the nth CompartmentType object in this Model.\n"
		"\n"
		"Parameter 'n' is the index of the object to return.\n"
		"\n"
		"Returns the nth CompartmentType of this Model. If the index 'n' is\n"
		"invalid, 'None' is returned.\n"
		"\n"
		"Note: The CompartmentType object class is only available in SBML Level\n"
		"2 Versions 2-4.  It is not available in Level 1 nor Level 3.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getCompartmentType(string sid)\n"
		"\n"
		"Get a CompartmentType object based on its identifier.\n"
		"\n"
		"Parameter 'sid' is the identifier to search for.\n"
		"\n"
		"Returns the CompartmentType in this Model with the identifier 'sid' or\n"
		"'None' if no such CompartmentType exists.\n"
		"\n"
		"Note: The CompartmentType object class is only available in SBML Level\n"
		"2 Versions 2-4.  It is not available in Level 1 nor Level 3.\n"
		"\n"
		""},
	 { "Model_getSpeciesType", _wrap_Model_getSpeciesType, METH_VARARGS, "\n"
		"Model_getSpeciesType(Model self, unsigned int n) -> SpeciesType\n"
		"Model_getSpeciesType(Model self, unsigned int n) -> SpeciesType\n"
		"Model_getSpeciesType(Model self, string sid) -> SpeciesType\n"
		"Model_getSpeciesType(Model self, string sid) -> SpeciesType\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getSpeciesType(long n)\n"
		"\n"
		"Get the nth SpeciesType object in this Model.\n"
		"\n"
		"Parameter 'n' is the index of the object to return.\n"
		"\n"
		"Returns the nth SpeciesType of this Model. If the index 'n' is\n"
		"invalid, 'None' is returned.\n"
		"\n"
		"Note: The SpeciesType object class is only available in SBML Level 2\n"
		"Versions 2-4.  It is not available in Level 1 nor Level 3.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getSpeciesType(string sid)\n"
		"\n"
		"Get a SpeciesType object based on its identifier.\n"
		"\n"
		"Parameter 'sid' is the identifier to search for.\n"
		"\n"
		"Returns the SpeciesType in this Model with the identifier 'sid' or\n"
		"'None' if no such SpeciesType exists.\n"
		"\n"
		"Note: The SpeciesType object class is only available in SBML Level 2\n"
		"Versions 2-4.  It is not available in Level 1 nor Level 3.\n"
		"\n"
		""},
	 { "Model_getCompartment", _wrap_Model_getCompartment, METH_VARARGS, "\n"
		"Model_getCompartment(Model self, unsigned int n) -> Compartment\n"
		"Model_getCompartment(Model self, unsigned int n) -> Compartment\n"
		"Model_getCompartment(Model self, string sid) -> Compartment\n"
		"Model_getCompartment(Model self, string sid) -> Compartment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getCompartment(long n)\n"
		"\n"
		"Get the nth Compartment object in this Model.\n"
		"\n"
		"Parameter 'n' is the index of the object to return.\n"
		"\n"
		"Returns the nth Compartment of this Model. If the index 'n' is\n"
		"invalid, 'None' is returned.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getCompartment(string sid)\n"
		"\n"
		"Get a Compartment object based on its identifier.\n"
		"\n"
		"Parameter 'sid' is the identifier to search for.\n"
		"\n"
		"Returns the Compartment in this Model with the identifier 'sid' or\n"
		"'None' if no such Compartment exists.\n"
		"\n"
		""},
	 { "Model_getSpecies", _wrap_Model_getSpecies, METH_VARARGS, "\n"
		"Model_getSpecies(Model self, unsigned int n) -> Species\n"
		"Model_getSpecies(Model self, unsigned int n) -> Species\n"
		"Model_getSpecies(Model self, string sid) -> Species\n"
		"Model_getSpecies(Model self, string sid) -> Species\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getSpecies(long n)\n"
		"\n"
		"Get the nth Species object in this Model.\n"
		"\n"
		"Parameter 'n' is the index of the object to return.\n"
		"\n"
		"Returns the nth Species of this Model. If the index 'n' is invalid,\n"
		"'None' is returned.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getSpecies(string sid)\n"
		"\n"
		"Get a Species object based on its identifier.\n"
		"\n"
		"Parameter 'sid' is the identifier to search for.\n"
		"\n"
		"Returns the Species in this Model with the identifier 'sid' or 'None'\n"
		"if no such Species exists.\n"
		"\n"
		""},
	 { "Model_getParameter", _wrap_Model_getParameter, METH_VARARGS, "\n"
		"Model_getParameter(Model self, unsigned int n) -> Parameter\n"
		"Model_getParameter(Model self, unsigned int n) -> Parameter\n"
		"Model_getParameter(Model self, string sid) -> Parameter\n"
		"Model_getParameter(Model self, string sid) -> Parameter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getParameter(long n)\n"
		"\n"
		"Get the nth Parameter object in this Model.\n"
		"\n"
		"Parameter 'n' is the index of the object to return.\n"
		"\n"
		"Returns the nth Parameter of this Model. If the index 'n' is invalid,\n"
		"'None' is returned.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getParameter(string sid)\n"
		"\n"
		"Get a Parameter object based on its identifier.\n"
		"\n"
		"Parameter 'sid' is the identifier to search for.\n"
		"\n"
		"Returns the Parameter in this Model with the identifier 'sid' or\n"
		"'None' if no such Parameter exists.\n"
		"\n"
		""},
	 { "Model_getInitialAssignment", _wrap_Model_getInitialAssignment, METH_VARARGS, "\n"
		"Model_getInitialAssignment(Model self, unsigned int n) -> InitialAssignment\n"
		"Model_getInitialAssignment(Model self, unsigned int n) -> InitialAssignment\n"
		"Model_getInitialAssignment(Model self, string symbol) -> InitialAssignment\n"
		"Model_getInitialAssignment(Model self, string symbol) -> InitialAssignment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getInitialAssignment(string symbol)\n"
		"\n"
		"Get an InitialAssignment object based on the symbol to which it\n"
		"assigns a value.\n"
		"\n"
		"Parameter 'symbol' is the symbol to search for.\n"
		"\n"
		"Returns the InitialAssignment in this Model with the given 'symbol'\n"
		"attribute value or 'None' if no such InitialAssignment exists.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getInitialAssignment(long n)\n"
		"\n"
		"Get the nth InitialAssignment object in this Model.\n"
		"\n"
		"Parameter 'n' is the index of the object to return.\n"
		"\n"
		"Returns the nth InitialAssignment of this Model. If the index 'n' is\n"
		"invalid, 'None' is returned.\n"
		"\n"
		""},
	 { "Model_getInitialAssignmentBySymbol", _wrap_Model_getInitialAssignmentBySymbol, METH_VARARGS, "\n"
		"Model_getInitialAssignmentBySymbol(Model self, string symbol) -> InitialAssignment\n"
		"Model_getInitialAssignmentBySymbol(Model self, string symbol) -> InitialAssignment\n"
		"\n"
		"Get an InitialAssignment object based on the symbol to which it\n"
		"assigns a value.\n"
		"\n"
		"Parameter 'symbol' is the symbol to search for.\n"
		"\n"
		"Returns the InitialAssignment in this Model with the given 'symbol'\n"
		"attribute value or 'None' if no such InitialAssignment exists.\n"
		"\n"
		""},
	 { "Model_getRule", _wrap_Model_getRule, METH_VARARGS, "\n"
		"Model_getRule(Model self, unsigned int n) -> Rule\n"
		"Model_getRule(Model self, unsigned int n) -> Rule\n"
		"Model_getRule(Model self, string variable) -> Rule\n"
		"Model_getRule(Model self, string variable) -> Rule\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getRule(string variable)\n"
		"\n"
		"Get a Rule object based on the variable to which it assigns a value.\n"
		"\n"
		"Parameter 'variable' is the variable to search for.\n"
		"\n"
		"Returns the Rule in this Model with the given 'variable' attribute\n"
		"value or 'None' if no such Rule exists.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getRule(long n)\n"
		"\n"
		"Get the nth Rule object in this Model.\n"
		"\n"
		"Parameter 'n' is the index of the object to return.\n"
		"\n"
		"Returns the nth Rule of this Model. If the index 'n' is invalid,\n"
		"'None' is returned.\n"
		"\n"
		""},
	 { "Model_getRuleByVariable", _wrap_Model_getRuleByVariable, METH_VARARGS, "\n"
		"Model_getRuleByVariable(Model self, string variable) -> Rule\n"
		"Model_getRuleByVariable(Model self, string variable) -> Rule\n"
		"\n"
		"Get a Rule object based on the variable to which it assigns a value.\n"
		"\n"
		"Parameter 'variable' is the variable to search for.\n"
		"\n"
		"Returns the Rule in this Model with the given 'variable' attribute\n"
		"value or 'None' if no such Rule exists.\n"
		"\n"
		""},
	 { "Model_getAssignmentRule", _wrap_Model_getAssignmentRule, METH_VARARGS, "\n"
		"Model_getAssignmentRule(Model self, string variable) -> AssignmentRule\n"
		"Model_getAssignmentRule(Model self, string variable) -> AssignmentRule\n"
		"\n"
		"Get a Rule object based on the variable to which it assigns a value.\n"
		"\n"
		"Parameter 'variable' is the variable to search for.\n"
		"\n"
		"Returns the Rule in this Model with the given 'variable' attribute\n"
		"value or 'None' if no such Rule exists.\n"
		"\n"
		""},
	 { "Model_getRateRule", _wrap_Model_getRateRule, METH_VARARGS, "\n"
		"Model_getRateRule(Model self, string variable) -> RateRule\n"
		"Model_getRateRule(Model self, string variable) -> RateRule\n"
		"\n"
		"Get a Rule object based on the variable to which it assigns a value.\n"
		"\n"
		"Parameter 'variable' is the symbol to search for.\n"
		"\n"
		"Returns the Rule in this Model with the given 'variable' attribute\n"
		"value or 'None' if no such Rule exists.\n"
		"\n"
		""},
	 { "Model_getAssignmentRuleByVariable", _wrap_Model_getAssignmentRuleByVariable, METH_VARARGS, "\n"
		"Model_getAssignmentRuleByVariable(Model self, string variable) -> AssignmentRule\n"
		"Model_getAssignmentRuleByVariable(Model self, string variable) -> AssignmentRule\n"
		"\n"
		"Get a Rule object based on the variable to which it assigns a value.\n"
		"\n"
		"Parameter 'variable' is the variable to search for.\n"
		"\n"
		"Returns the Rule in this Model with the given 'variable' attribute\n"
		"value or 'None' if no such Rule exists.\n"
		"\n"
		""},
	 { "Model_getRateRuleByVariable", _wrap_Model_getRateRuleByVariable, METH_VARARGS, "\n"
		"Model_getRateRuleByVariable(Model self, string variable) -> RateRule\n"
		"Model_getRateRuleByVariable(Model self, string variable) -> RateRule\n"
		"\n"
		"Get a Rule object based on the variable to which it assigns a value.\n"
		"\n"
		"Parameter 'variable' is the variable to search for.\n"
		"\n"
		"Returns the Rule in this Model with the given 'variable' attribute\n"
		"value or 'None' if no such Rule exists.\n"
		"\n"
		""},
	 { "Model_getConstraint", _wrap_Model_getConstraint, METH_VARARGS, "\n"
		"Model_getConstraint(Model self, unsigned int n) -> Constraint\n"
		"Model_getConstraint(Model self, unsigned int n) -> Constraint\n"
		"\n"
		"Get the nth Constraint object in this Model.\n"
		"\n"
		"Parameter 'n' is the index of the object to return.\n"
		"\n"
		"Returns the nth Constraint of this Model. If the index 'n' is invalid,\n"
		"'None' is returned.\n"
		"\n"
		""},
	 { "Model_getReaction", _wrap_Model_getReaction, METH_VARARGS, "\n"
		"Model_getReaction(Model self, unsigned int n) -> Reaction\n"
		"Model_getReaction(Model self, unsigned int n) -> Reaction\n"
		"Model_getReaction(Model self, string sid) -> Reaction\n"
		"Model_getReaction(Model self, string sid) -> Reaction\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getReaction(long n)\n"
		"\n"
		"Get the nth Reaction object in this Model.\n"
		"\n"
		"Parameter 'n' is the index of the object to return.\n"
		"\n"
		"Returns the nth Reaction of this Model. If the index 'n' is invalid,\n"
		"'None' is returned.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getReaction(string sid)\n"
		"\n"
		"Get a Reaction object based on its identifier.\n"
		"\n"
		"Parameter 'sid' is the identifier to search for.\n"
		"\n"
		"Returns the Reaction in this Model with the identifier 'sid' or 'None'\n"
		"if no such Reaction exists.\n"
		"\n"
		""},
	 { "Model_getSpeciesReference", _wrap_Model_getSpeciesReference, METH_VARARGS, "\n"
		"Model_getSpeciesReference(Model self, string sid) -> SpeciesReference\n"
		"Model_getSpeciesReference(Model self, string sid) -> SpeciesReference\n"
		"\n"
		"Get a SpeciesReference object based on its identifier.\n"
		"\n"
		"Parameter 'sid' is the identifier to search for.\n"
		"\n"
		"Returns the SpeciesReference in this Model with the identifier 'sid'\n"
		"or 'None' if no such SpeciesReference exists.\n"
		"\n"
		""},
	 { "Model_getModifierSpeciesReference", _wrap_Model_getModifierSpeciesReference, METH_VARARGS, "\n"
		"Model_getModifierSpeciesReference(Model self, string sid) -> ModifierSpeciesReference\n"
		"Model_getModifierSpeciesReference(Model self, string sid) -> ModifierSpeciesReference\n"
		"\n"
		"Get a ModifierSpeciesReference object based on its identifier.\n"
		"\n"
		"Parameter 'sid' is the identifier to search for.\n"
		"\n"
		"Returns the ModifierSpeciesReference in this Model with the\n"
		"identifier 'sid' or 'None' if no such ModifierSpeciesReference exists.\n"
		"\n"
		""},
	 { "Model_getEvent", _wrap_Model_getEvent, METH_VARARGS, "\n"
		"Model_getEvent(Model self, unsigned int n) -> Event\n"
		"Model_getEvent(Model self, unsigned int n) -> Event\n"
		"Model_getEvent(Model self, string sid) -> Event\n"
		"Model_getEvent(Model self, string sid) -> Event\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getEvent(long n)\n"
		"\n"
		"Get the nth Event object in this Model.\n"
		"\n"
		"Parameter 'n' is the index of the object to return.\n"
		"\n"
		"Returns the nth Event of this Model. If the index 'n' is invalid,\n"
		"'None' is returned.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getEvent(string sid)\n"
		"\n"
		"Get an Event object based on its identifier.\n"
		"\n"
		"Parameter 'sid' is the identifier to search for.\n"
		"\n"
		"Returns the Event in this Model with the identifier 'sid' or 'None' if\n"
		"no such Event exists.\n"
		"\n"
		""},
	 { "Model_getNumFunctionDefinitions", _wrap_Model_getNumFunctionDefinitions, METH_O, "\n"
		"Model_getNumFunctionDefinitions(Model self) -> unsigned int\n"
		"\n"
		"Get the number of FunctionDefinition objects in this Model.\n"
		"\n"
		"Returns the number of FunctionDefinitions in this Model.\n"
		"\n"
		""},
	 { "Model_getNumUnitDefinitions", _wrap_Model_getNumUnitDefinitions, METH_O, "\n"
		"Model_getNumUnitDefinitions(Model self) -> unsigned int\n"
		"\n"
		"Get the number of UnitDefinition objects in this Model.\n"
		"\n"
		"Returns the number of UnitDefinitions in this Model.\n"
		"\n"
		""},
	 { "Model_getNumCompartmentTypes", _wrap_Model_getNumCompartmentTypes, METH_O, "\n"
		"Model_getNumCompartmentTypes(Model self) -> unsigned int\n"
		"\n"
		"Get the number of CompartmentType objects in this Model.\n"
		"\n"
		"Returns the number of CompartmentTypes in this Model.\n"
		"\n"
		"Note: The CompartmentType object class is only available in SBML Level\n"
		"2 Versions 2-4.  It is not available in Level 1 nor Level 3.\n"
		"\n"
		""},
	 { "Model_getNumSpeciesTypes", _wrap_Model_getNumSpeciesTypes, METH_O, "\n"
		"Model_getNumSpeciesTypes(Model self) -> unsigned int\n"
		"\n"
		"Get the number of SpeciesType objects in this Model.\n"
		"\n"
		"Returns the number of SpeciesTypes in this Model.\n"
		"\n"
		"Note: The SpeciesType object class is only available in SBML Level 2\n"
		"Versions 2-4.  It is not available in Level 1 nor Level 3.\n"
		"\n"
		""},
	 { "Model_getNumCompartments", _wrap_Model_getNumCompartments, METH_O, "\n"
		"Model_getNumCompartments(Model self) -> unsigned int\n"
		"\n"
		"Get the number of Compartment objects in this Model.\n"
		"\n"
		"Returns the number of Compartments in this Model.\n"
		"\n"
		""},
	 { "Model_getNumSpecies", _wrap_Model_getNumSpecies, METH_O, "\n"
		"Model_getNumSpecies(Model self) -> unsigned int\n"
		"\n"
		"Get the number of Species objects in this Model.\n"
		"\n"
		"Returns the number of Species in this Model.\n"
		"\n"
		""},
	 { "Model_getNumSpeciesWithBoundaryCondition", _wrap_Model_getNumSpeciesWithBoundaryCondition, METH_O, "\n"
		"Model_getNumSpeciesWithBoundaryCondition(Model self) -> unsigned int\n"
		"\n"
		"Get the number of Species in this Model having their\n"
		"'boundaryCondition' attribute value set to 'True.'\n"
		"\n"
		"Returns the number of Species in this Model with boundaryCondition set\n"
		"to true.\n"
		"\n"
		""},
	 { "Model_getNumParameters", _wrap_Model_getNumParameters, METH_O, "\n"
		"Model_getNumParameters(Model self) -> unsigned int\n"
		"\n"
		"Get the number of Parameter objects in this Model.\n"
		"\n"
		"Returns the number of Parameters in this Model.  Parameters defined in\n"
		"KineticLaws are not included.\n"
		"\n"
		""},
	 { "Model_getNumInitialAssignments", _wrap_Model_getNumInitialAssignments, METH_O, "\n"
		"Model_getNumInitialAssignments(Model self) -> unsigned int\n"
		"\n"
		"Get the number of InitialAssignment objects in this Model.\n"
		"\n"
		"Returns the number of InitialAssignments in this Model.\n"
		"\n"
		""},
	 { "Model_getNumRules", _wrap_Model_getNumRules, METH_O, "\n"
		"Model_getNumRules(Model self) -> unsigned int\n"
		"\n"
		"Get the number of Rule objects in this Model.\n"
		"\n"
		"Returns the number of Rules in this Model.\n"
		"\n"
		""},
	 { "Model_getNumConstraints", _wrap_Model_getNumConstraints, METH_O, "\n"
		"Model_getNumConstraints(Model self) -> unsigned int\n"
		"\n"
		"Get the number of Constraint objects in this Model.\n"
		"\n"
		"Returns the number of Constraints in this Model.\n"
		"\n"
		""},
	 { "Model_getNumReactions", _wrap_Model_getNumReactions, METH_O, "\n"
		"Model_getNumReactions(Model self) -> unsigned int\n"
		"\n"
		"Get the number of Reaction objects in this Model.\n"
		"\n"
		"Returns the number of Reactions in this Model.\n"
		"\n"
		""},
	 { "Model_getNumEvents", _wrap_Model_getNumEvents, METH_O, "\n"
		"Model_getNumEvents(Model self) -> unsigned int\n"
		"\n"
		"Get the number of Event objects in this Model.\n"
		"\n"
		"Returns the number of Events in this Model.\n"
		"\n"
		""},
	 { "Model_removeFromParentAndDelete", _wrap_Model_removeFromParentAndDelete, METH_O, "\n"
		"Model_removeFromParentAndDelete(Model self) -> int\n"
		"\n"
		"Remove this Model from its parent SBMLDocument object.\n"
		"\n"
		"This works by finding this Model's parent SBMLDocument and then\n"
		"calling setModel(None) on it, indirectly deleting itself. Overridden\n"
		"from the SBase function since the parent is not a ListOf.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Model_renameAllIds", _wrap_Model_renameAllIds, METH_VARARGS, "\n"
		"Model_renameAllIds(Model self, IdentifierTransformer idTransformer, ElementFilter filter=None) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_renameSIdRefs", _wrap_Model_renameSIdRefs, METH_VARARGS, "\n"
		"Model_renameSIdRefs(Model self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Model_renameUnitSIdRefs", _wrap_Model_renameUnitSIdRefs, METH_VARARGS, "\n"
		"Model_renameUnitSIdRefs(Model self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Model_convertL1ToL2", _wrap_Model_convertL1ToL2, METH_O, "\n"
		"Model_convertL1ToL2(Model self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_convertL1ToL3", _wrap_Model_convertL1ToL3, METH_VARARGS, "\n"
		"Model_convertL1ToL3(Model self, bool addDefaultUnits=True)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_convertL2ToL3", _wrap_Model_convertL2ToL3, METH_VARARGS, "\n"
		"Model_convertL2ToL3(Model self, bool strict=False, bool addDefaultUnits=True)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_convertL2ToL1", _wrap_Model_convertL2ToL1, METH_VARARGS, "\n"
		"Model_convertL2ToL1(Model self, bool strict=False)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_convertL3ToL1", _wrap_Model_convertL3ToL1, METH_VARARGS, "\n"
		"Model_convertL3ToL1(Model self, bool strict=False)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_convertL3ToL2", _wrap_Model_convertL3ToL2, METH_VARARGS, "\n"
		"Model_convertL3ToL2(Model self, bool strict=False)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_convertFromL3V2", _wrap_Model_convertFromL3V2, METH_VARARGS, "\n"
		"Model_convertFromL3V2(Model self, bool strict=False)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_dealWithFast", _wrap_Model_dealWithFast, METH_O, "\n"
		"Model_dealWithFast(Model self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_dealWithL3Fast", _wrap_Model_dealWithL3Fast, METH_VARARGS, "\n"
		"Model_dealWithL3Fast(Model self, unsigned int targetVersion)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_addModifiers", _wrap_Model_addModifiers, METH_O, "\n"
		"Model_addModifiers(Model self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_addConstantAttribute", _wrap_Model_addConstantAttribute, METH_O, "\n"
		"Model_addConstantAttribute(Model self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_setSpatialDimensions", _wrap_Model_setSpatialDimensions, METH_VARARGS, "\n"
		"Model_setSpatialDimensions(Model self, double dims=3.0)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_addDefinitionsForDefaultUnits", _wrap_Model_addDefinitionsForDefaultUnits, METH_O, "\n"
		"Model_addDefinitionsForDefaultUnits(Model self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_dealWithDefaultValues", _wrap_Model_dealWithDefaultValues, METH_O, "\n"
		"Model_dealWithDefaultValues(Model self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_convertParametersToLocals", _wrap_Model_convertParametersToLocals, METH_VARARGS, "\n"
		"Model_convertParametersToLocals(Model self, unsigned int level, unsigned int version)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_setSpeciesReferenceConstantValueAndStoichiometry", _wrap_Model_setSpeciesReferenceConstantValueAndStoichiometry, METH_O, "\n"
		"Model_setSpeciesReferenceConstantValueAndStoichiometry(Model self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_removeParameterRuleUnits", _wrap_Model_removeParameterRuleUnits, METH_VARARGS, "\n"
		"Model_removeParameterRuleUnits(Model self, bool strict)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_convertStoichiometryMath", _wrap_Model_convertStoichiometryMath, METH_O, "\n"
		"Model_convertStoichiometryMath(Model self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_assignRequiredValues", _wrap_Model_assignRequiredValues, METH_O, "\n"
		"Model_assignRequiredValues(Model self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_dealWithModelUnits", _wrap_Model_dealWithModelUnits, METH_VARARGS, "\n"
		"Model_dealWithModelUnits(Model self, bool strict=False)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_dealWithStoichiometry", _wrap_Model_dealWithStoichiometry, METH_O, "\n"
		"Model_dealWithStoichiometry(Model self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_dealWithEvents", _wrap_Model_dealWithEvents, METH_VARARGS, "\n"
		"Model_dealWithEvents(Model self, bool strict)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_removeSpeciesTypes", _wrap_Model_removeSpeciesTypes, METH_O, "\n"
		"Model_removeSpeciesTypes(Model self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_removeCompartmentTypes", _wrap_Model_removeCompartmentTypes, METH_O, "\n"
		"Model_removeCompartmentTypes(Model self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_connectToChild", _wrap_Model_connectToChild, METH_O, "Model_connectToChild(Model self)"},
	 { "Model_getTypeCode", _wrap_Model_getTypeCode, METH_O, "\n"
		"Model_getTypeCode(Model self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_MODEL (default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "Model_getElementName", _wrap_Model_getElementName, METH_O, "\n"
		"Model_getElementName(Model self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for Model, is\n"
		"always ''model'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''model'.'\n"
		"\n"
		""},
	 { "Model_populateListFormulaUnitsData", _wrap_Model_populateListFormulaUnitsData, METH_O, "\n"
		"Model_populateListFormulaUnitsData(Model self)\n"
		"\n"
		"Populates the internal list of derived units for this Model object.\n"
		"\n"
		"This method tells libSBML to (re)calculate all units for all\n"
		"components of the enclosing Model object.  The result is stored in an\n"
		"internal list of unit data.  Users can access the resulting data by\n"
		"calling the method SBase.getDerivedUnitDefinition() available on most\n"
		"objects.  (The name 'formula units data' is drawn from the name of the\n"
		"internal objects libSBML uses to store the data; note that these\n"
		"internal objects are not exposed to callers, because callers can\n"
		"interact with the results using the ordinary SBML unit objects.)\n"
		"\n"
		"This method is used by libSBML itself in the validator concerned with\n"
		"unit consistency.  The unit consistency validator (like all other\n"
		"validators in libSBML) is invoked by using\n"
		"SBMLDocument.checkConsistency(), with the consistency checks for the\n"
		"category LIBSBML_CAT_UNITS_CONSISTENCY turned on.  The method\n"
		"populateListFormulaUnitsData() does not need to be called prior to\n"
		"invoking the validator if unit consistency checking has not been\n"
		"turned off.  This method is only provided for cases when callers have\n"
		"a special need to force the unit data to be recalculated.  For\n"
		"instance, during construction of a model, a caller may want to\n"
		"interrogate libSBML's inferred units without invoking full-blown model\n"
		"validation; this is a scenario in which calling\n"
		"populateListFormulaUnitsData() may be useful.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Computing and inferring units is a time-consuming operation. Callers\n"
		"may want to call isPopulatedListFormulaUnitsData() to determine\n"
		"whether the units may already have been computed, to save themselves\n"
		"the need of invoking unit inference unnecessarily.\n"
		"\n"
		"See also isPopulatedListFormulaUnitsData().\n"
		"\n"
		""},
	 { "Model_isPopulatedListFormulaUnitsData", _wrap_Model_isPopulatedListFormulaUnitsData, METH_O, "\n"
		"Model_isPopulatedListFormulaUnitsData(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if libSBML has derived units for the\n"
		"components of this model.\n"
		"\n"
		"LibSBML can infer the units of measurement associated with different\n"
		"elements of a model.  When libSBML does that, it builds a complex\n"
		"internal structure during a resource-intensive operation.  This is\n"
		"done automatically only when callers invoke validation (via\n"
		"SBMLDocument.checkConsistency()) and have not turned off the unit\n"
		"validation option.\n"
		"\n"
		"Callers can force units to be recalculated by calling\n"
		"populateListFormulaUnitsData().  To avoid calling that method\n"
		"unnecessarily, calling programs may first want to invoke this method\n"
		"(isPopulatedListFormulaUnitsData()) to determine whether it is even\n"
		"necessary.\n"
		"\n"
		"Returns 'True' if the units have already been computed, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Model_getFormulaUnitsDataForVariable", _wrap_Model_getFormulaUnitsDataForVariable, METH_VARARGS, "\n"
		"Model_getFormulaUnitsDataForVariable(Model self, string sid) -> FormulaUnitsData *\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_getFormulaUnitsDataForAssignment", _wrap_Model_getFormulaUnitsDataForAssignment, METH_VARARGS, "\n"
		"Model_getFormulaUnitsDataForAssignment(Model self, string sid) -> FormulaUnitsData *\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_populateAllElementIdList", _wrap_Model_populateAllElementIdList, METH_O, "\n"
		"Model_populateAllElementIdList(Model self)\n"
		"\n"
		"Populates the internal list of the identifiers of all elements within\n"
		"this Model object.\n"
		"\n"
		"This method tells libSBML to retrieve the identifiers of all elements\n"
		"of the enclosing Model object.  The result is stored in an internal\n"
		"list of ids.  Users can access the resulting data by calling the\n"
		"method getAllElementIdList().\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Retrieving all elements within a model is a time-consuming operation.\n"
		"Callers may want to call isPopulatedAllElementIdList() to determine\n"
		"whether the id list may already have been populated.\n"
		"\n"
		"See also isPopulatedAllElementIdList().\n"
		"\n"
		""},
	 { "Model_isPopulatedAllElementIdList", _wrap_Model_isPopulatedAllElementIdList, METH_O, "\n"
		"Model_isPopulatedAllElementIdList(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if libSBML has a list of the ids of all\n"
		"components of this model.\n"
		"\n"
		"Returns 'True' if the id list has already been populated, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Model_getAllElementIdList", _wrap_Model_getAllElementIdList, METH_O, "\n"
		"Model_getAllElementIdList(Model self) -> IdList\n"
		"\n"
		"Returns the internal list of the identifiers of all elements within\n"
		"this Model object.\n"
		"\n"
		"Returns an IdList of all the identifiers in the model.\n"
		"\n"
		"See also populateAllElementIdList(), isPopulatedAllElementIdList().\n"
		"\n"
		""},
	 { "Model_clearAllElementIdList", _wrap_Model_clearAllElementIdList, METH_O, "\n"
		"Model_clearAllElementIdList(Model self)\n"
		"\n"
		"Clears the internal list of the identifiers of all elements within\n"
		"this Model object.\n"
		"\n"
		"See also populateAllElementIdList(), isPopulatedAllElementIdList().\n"
		"\n"
		""},
	 { "Model_populateAllElementMetaIdList", _wrap_Model_populateAllElementMetaIdList, METH_O, "\n"
		"Model_populateAllElementMetaIdList(Model self)\n"
		"\n"
		"Populates the internal list of the metaids of all elements within this\n"
		"Model object.\n"
		"\n"
		"This method tells libSBML to retrieve the identifiers of all elements\n"
		"of the enclosing Model object.  The result is stored in an internal\n"
		"list of metaids.  Users can access the resulting data by calling the\n"
		"method getAllElementMetaIdList().\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Retrieving all elements within a model is a time-consuming operation.\n"
		"Callers may want to call isPopulatedAllElementMetaIdList() to\n"
		"determine whether the metaid list may already have been populated.\n"
		"\n"
		"See also isPopulatedAllElementMetaIdList().\n"
		"\n"
		""},
	 { "Model_isPopulatedAllElementMetaIdList", _wrap_Model_isPopulatedAllElementMetaIdList, METH_O, "\n"
		"Model_isPopulatedAllElementMetaIdList(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if libSBML has a list of the metaids of all\n"
		"components of this model.\n"
		"\n"
		"Returns 'True' if the metaid list has already been populated, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Model_getAllElementMetaIdList", _wrap_Model_getAllElementMetaIdList, METH_O, "\n"
		"Model_getAllElementMetaIdList(Model self) -> IdList\n"
		"\n"
		"Returns the internal list of the metaids of all elements within this\n"
		"Model object.\n"
		"\n"
		"Returns an IdList of all the metaids in the model.\n"
		"\n"
		"See also populateAllElementMetaIdList(),\n"
		"isPopulatedAllElementMetaIdList().\n"
		"\n"
		""},
	 { "Model_clearAllElementMetaIdList", _wrap_Model_clearAllElementMetaIdList, METH_O, "\n"
		"Model_clearAllElementMetaIdList(Model self)\n"
		"\n"
		"Clears the internal list of the metaids of all elements within this\n"
		"Model object.\n"
		"\n"
		"See also populateAllElementMetaIdList(),\n"
		"isPopulatedAllElementMetaIdList().\n"
		"\n"
		""},
	 { "Model_hasRequiredElements", _wrap_Model_hasRequiredElements, METH_O, "\n"
		"Model_hasRequiredElements(Model self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this Model\n"
		"object have been set.\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "Model_removeFunctionDefinition", _wrap_Model_removeFunctionDefinition, METH_VARARGS, "\n"
		"Model_removeFunctionDefinition(Model self, unsigned int n) -> FunctionDefinition\n"
		"Model_removeFunctionDefinition(Model self, string sid) -> FunctionDefinition\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeFunctionDefinition(long n)\n"
		"\n"
		"Removes the nth FunctionDefinition object from this Model object and\n"
		"returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the FunctionDefinition object to remove.\n"
		"\n"
		"Returns the FunctionDefinition object removed, or 'None' if the given\n"
		"index is out of range.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeFunctionDefinition(string sid)\n"
		"\n"
		"Removes the FunctionDefinition object with the given identifier from\n"
		"this Model  object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the FunctionDefinition object to\n"
		"remove.\n"
		"\n"
		"Returns the FunctionDefinition object removed, or 'None' if no\n"
		"FunctionDefinition object with the identifier exists in this Model\n"
		"object.\n"
		"\n"
		""},
	 { "Model_removeUnitDefinition", _wrap_Model_removeUnitDefinition, METH_VARARGS, "\n"
		"Model_removeUnitDefinition(Model self, unsigned int n) -> UnitDefinition\n"
		"Model_removeUnitDefinition(Model self, string sid) -> UnitDefinition\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeUnitDefinition(long n)\n"
		"\n"
		"Removes the nth UnitDefinition object from this Model object and\n"
		"returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the UnitDefinition object to remove.\n"
		"\n"
		"Returns the UnitDefinition object removed., or 'None' if the given\n"
		"index is out of range.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeUnitDefinition(string sid)\n"
		"\n"
		"Removes the UnitDefinition object with the given identifier from this\n"
		"Model object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the UnitDefinition object to\n"
		"remove.\n"
		"\n"
		"Returns the UnitDefinition object removed, or 'None' if no\n"
		"UnitDefinition object with the identifier exists in this Model object.\n"
		"\n"
		""},
	 { "Model_removeCompartmentType", _wrap_Model_removeCompartmentType, METH_VARARGS, "\n"
		"Model_removeCompartmentType(Model self, unsigned int n) -> CompartmentType\n"
		"Model_removeCompartmentType(Model self, string sid) -> CompartmentType\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeCompartmentType(long n)\n"
		"\n"
		"Removes the nth CompartmentType object from this Model object and\n"
		"returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the CompartmentType object to remove.\n"
		"\n"
		"Returns the ComapartmentType object removed, or 'None' if the given\n"
		"index is out of range.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeCompartmentType(string sid)\n"
		"\n"
		"Removes the CompartmentType object with the given identifier from this\n"
		"Model object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the object to remove.\n"
		"\n"
		"Returns the CompartmentType object removed, or 'None' if no\n"
		"CompartmentType object with the identifier exists in this Model\n"
		"object.\n"
		"\n"
		""},
	 { "Model_removeSpeciesType", _wrap_Model_removeSpeciesType, METH_VARARGS, "\n"
		"Model_removeSpeciesType(Model self, unsigned int n) -> SpeciesType\n"
		"Model_removeSpeciesType(Model self, string sid) -> SpeciesType\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeSpeciesType(long n)\n"
		"\n"
		"Removes the nth SpeciesType object from this Model object and returns\n"
		"a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the SpeciesType object to remove.\n"
		"\n"
		"Returns the SpeciesType object removed, or 'None' if the given index\n"
		"is out of range.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeSpeciesType(string sid)\n"
		"\n"
		"Removes the SpeciesType object with the given identifier from this\n"
		"Model object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the SpeciesType object to remove.\n"
		"\n"
		"Returns the SpeciesType object removed, or 'None' if no SpeciesType\n"
		"object with the identifier exists in this Model object.\n"
		"\n"
		""},
	 { "Model_removeCompartment", _wrap_Model_removeCompartment, METH_VARARGS, "\n"
		"Model_removeCompartment(Model self, unsigned int n) -> Compartment\n"
		"Model_removeCompartment(Model self, string sid) -> Compartment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeCompartment(long n)\n"
		"\n"
		"Removes the nth Compartment object from this Model object and returns\n"
		"a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the Compartment object to remove.\n"
		"\n"
		"Returns the Compartment object removed, or 'None' if the given index\n"
		"is out of range.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeCompartment(string sid)\n"
		"\n"
		"Removes the Compartment object with the given identifier from this\n"
		"Model object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the Compartment object to remove.\n"
		"\n"
		"Returns the Compartment object removed, or 'None' if no Compartment\n"
		"object with the identifier exists in this Model object.\n"
		"\n"
		""},
	 { "Model_removeSpecies", _wrap_Model_removeSpecies, METH_VARARGS, "\n"
		"Model_removeSpecies(Model self, unsigned int n) -> Species\n"
		"Model_removeSpecies(Model self, string sid) -> Species\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeSpecies(long n)\n"
		"\n"
		"Removes the nth Species object from this Model object and returns a\n"
		"pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the Species object to remove.\n"
		"\n"
		"Returns the Species object removed, or 'None' if the given index is\n"
		"out of range.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeSpecies(string sid)\n"
		"\n"
		"Removes the Species object with the given identifier from this Model\n"
		"object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the Species object to remove.\n"
		"\n"
		"Returns the Species object removed, or 'None' if no Species object\n"
		"with the identifier exists in this Model object.\n"
		"\n"
		""},
	 { "Model_removeParameter", _wrap_Model_removeParameter, METH_VARARGS, "\n"
		"Model_removeParameter(Model self, unsigned int n) -> Parameter\n"
		"Model_removeParameter(Model self, string sid) -> Parameter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeParameter(long n)\n"
		"\n"
		"Removes the nth Parameter object from this Model object and returns a\n"
		"pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the Parameter object to remove.\n"
		"\n"
		"Returns the Parameter object removed, or 'None' if the given index is\n"
		"out of range.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeParameter(string sid)\n"
		"\n"
		"Removes the Parameter object with the given identifier from this Model\n"
		"object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the Parameter object to remove.\n"
		"\n"
		"Returns the Parameter object removed, or 'None' if no Parameter object\n"
		"with the identifier exists in this Model object.\n"
		"\n"
		""},
	 { "Model_removeInitialAssignment", _wrap_Model_removeInitialAssignment, METH_VARARGS, "\n"
		"Model_removeInitialAssignment(Model self, unsigned int n) -> InitialAssignment\n"
		"Model_removeInitialAssignment(Model self, string symbol) -> InitialAssignment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeInitialAssignment(string symbol)\n"
		"\n"
		"Removes the InitialAssignment object with the given 'symbol' attribute\n"
		"from this Model object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'symbol' is the 'symbol' attribute of the InitialAssignment\n"
		"object to remove.\n"
		"\n"
		"Returns the InitialAssignment object removed, or 'None' if no\n"
		"InitialAssignment object with the 'symbol' attribute exists in this\n"
		"Model object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeInitialAssignment(long n)\n"
		"\n"
		"Removes the nth InitialAssignment object from this Model object and\n"
		"returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the InitialAssignment object to remove.\n"
		"\n"
		"Returns the InitialAssignment object removed, or 'None' if the given\n"
		"index is out of range.\n"
		"\n"
		""},
	 { "Model_removeRule", _wrap_Model_removeRule, METH_VARARGS, "\n"
		"Model_removeRule(Model self, unsigned int n) -> Rule\n"
		"Model_removeRule(Model self, string variable) -> Rule\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeRule(string variable)\n"
		"\n"
		"Removes the Rule object with the given 'variable' attribute from this\n"
		"Model  object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'variable' is the 'variable' attribute of the Rule object to\n"
		"remove.\n"
		"\n"
		"Returns the Rule object removed, or 'None' if no Rule object with the\n"
		"'variable' attribute exists in this Model object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeRule(long n)\n"
		"\n"
		"Removes the nth Rule object from this Model object and returns a\n"
		"pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the Rule object to remove.\n"
		"\n"
		"Returns the Rule object removed, or 'None' if the given index is out\n"
		"of range.\n"
		"\n"
		""},
	 { "Model_removeRuleByVariable", _wrap_Model_removeRuleByVariable, METH_VARARGS, "\n"
		"Model_removeRuleByVariable(Model self, string variable) -> Rule\n"
		"\n"
		"Removes the Rule object with the given 'variable' attribute from this\n"
		"Model  object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'variable' is the 'variable' attribute of the Rule object to\n"
		"remove.\n"
		"\n"
		"Returns the Rule object removed, or 'None' if no Rule object with the\n"
		"'variable' attribute exists in this Model object.\n"
		"\n"
		""},
	 { "Model_removeConstraint", _wrap_Model_removeConstraint, METH_VARARGS, "\n"
		"Model_removeConstraint(Model self, unsigned int n) -> Constraint\n"
		"\n"
		"Removes the nth Constraint object from this Model object and returns a\n"
		"pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the Constraint object to remove.\n"
		"\n"
		"Returns the Constraint object removed, or 'None' if the given index is\n"
		"out of range.\n"
		"\n"
		""},
	 { "Model_removeReaction", _wrap_Model_removeReaction, METH_VARARGS, "\n"
		"Model_removeReaction(Model self, unsigned int n) -> Reaction\n"
		"Model_removeReaction(Model self, string sid) -> Reaction\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeReaction(long n)\n"
		"\n"
		"Removes the nth Reaction object from this Model object and returns a\n"
		"pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the Reaction object to remove.\n"
		"\n"
		"Returns the Reaction object removed, or 'None' if the given index is\n"
		"out of range.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeReaction(string sid)\n"
		"\n"
		"Removes the Reaction object with the given identifier from this Model\n"
		"object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the Reaction object to remove.\n"
		"\n"
		"Returns the Reaction object removed, or 'None' if no Reaction object\n"
		"with the identifier exists in this Model object.\n"
		"\n"
		""},
	 { "Model_removeEvent", _wrap_Model_removeEvent, METH_VARARGS, "\n"
		"Model_removeEvent(Model self, unsigned int n) -> Event\n"
		"Model_removeEvent(Model self, string sid) -> Event\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeEvent(long n)\n"
		"\n"
		"Removes the nth Event object from this Model object and returns a\n"
		"pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the Event object to remove.\n"
		"\n"
		"Returns the Event object removed, or 'None' if the given index is out\n"
		"of range.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeEvent(string sid)\n"
		"\n"
		"Removes the Event object with the given identifier from this Model\n"
		"object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the Event object to remove.\n"
		"\n"
		"Returns the Event object removed, or 'None' if no Event object with\n"
		"the identifier exists in this Model object.\n"
		"\n"
		""},
	 { "Model_appendFrom", _wrap_Model_appendFrom, METH_VARARGS, "\n"
		"Model_appendFrom(Model self, Model model) -> int\n"
		"\n"
		"Copies a given Model object's subcomponents and appends the copies to\n"
		"the appropriate places in this Model.\n"
		"\n"
		"This method also calls the appendFrom method on all libSBML plug-in\n"
		"objects.\n"
		"\n"
		"SBML Level 3 consists of a Core definition that can be extended via\n"
		"optional SBML Level 3 packages.  A given model may indicate that it\n"
		"uses one or more SBML packages, and likewise, a software tool may be\n"
		"able to support one or more packages.  LibSBML does not come\n"
		"preconfigured with all possible packages included and enabled, in part\n"
		"because not all package specifications have been finalized.  To\n"
		"support the ability for software systems to enable support for the\n"
		"Level 3 packages they choose, libSBML features a plug-in mechanism.\n"
		"Each SBML Level 3 package is implemented in a separate code plug-in\n"
		"that can be enabled by the application to support working with that\n"
		"SBML package.  A given SBML model may thus contain not only objects\n"
		"defined by SBML Level 3 Core, but also objects created by libSBML\n"
		"plug-ins supporting additional Level 3 packages.\n"
		"\n"
		"Parameter 'model' is the Model to merge with this one.\n"
		"\n"
		""},
	 { "Model_enablePackageInternal", _wrap_Model_enablePackageInternal, METH_VARARGS, "\n"
		"Model_enablePackageInternal(Model self, string pkgURI, string pkgPrefix, bool flag)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_updateSBMLNamespace", _wrap_Model_updateSBMLNamespace, METH_VARARGS, "\n"
		"Model_updateSBMLNamespace(Model self, string package, unsigned int level, unsigned int version)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_renameIDs", _wrap_Model_renameIDs, METH_VARARGS, "\n"
		"Model_renameIDs(Model self, SBaseList elements, IdentifierTransformer idTransformer)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Model_swigregister", Model_swigregister, METH_O, NULL},
	 { "Model_swiginit", Model_swiginit, METH_VARARGS, NULL},
	 { "SBMLDocument_getDefaultLevel", _wrap_SBMLDocument_getDefaultLevel, METH_NOARGS, "\n"
		"SBMLDocument_getDefaultLevel() -> unsigned int\n"
		"\n"
		"The default SBML Level of new SBMLDocument objects.\n"
		"\n"
		"This 'default Level' corresponds to the most recent SBML\n"
		"specification Level available at the time libSBML version 5.19.0 was\n"
		"released.  The default Level is used by SBMLDocument if no Level is\n"
		"explicitly specified at the time of the construction of an\n"
		"SBMLDocument instance.\n"
		"\n"
		"Returns an integer indicating the most recent SBML specification\n"
		"Level.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also SBMLDocument.getDefaultVersion() .\n"
		"\n"
		""},
	 { "SBMLDocument_getDefaultVersion", _wrap_SBMLDocument_getDefaultVersion, METH_NOARGS, "\n"
		"SBMLDocument_getDefaultVersion() -> unsigned int\n"
		"\n"
		"The default Version of new SBMLDocument objects.\n"
		"\n"
		"This 'default Version' corresponds to the most recent Version within\n"
		"the most recent Level of SBML available at the time libSBML version\n"
		"5.19.0 was released.  The default Version is used by SBMLDocument if\n"
		"no Version is explicitly specified at the time of the construction of\n"
		"an SBMLDocument instance.\n"
		"\n"
		"Returns an integer indicating the most recent SBML specification\n"
		"Version.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also SBMLDocument.getDefaultLevel() .\n"
		"\n"
		""},
	 { "delete_SBMLDocument", _wrap_delete_SBMLDocument, METH_O, "delete_SBMLDocument(SBMLDocument self)"},
	 { "new_SBMLDocument", _wrap_new_SBMLDocument, METH_VARARGS, "\n"
		"SBMLDocument(unsigned int level=0, unsigned int version=0)\n"
		"SBMLDocument(SBMLNamespaces sbmlns)\n"
		"new_SBMLDocument(SBMLDocument orig) -> SBMLDocument\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLDocument(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new SBMLDocument using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLDocument(long level = 0, long version = 0)\n"
		"\n"
		"Creates a new SBMLDocument, optionally with given values for the SBML\n"
		"Level and Version.\n"
		"\n"
		"If both the SBML Level and Version attributes are not specified, the\n"
		"SBML document is treated as having the latest Level and Version of\n"
		"SBML as determined by SBMLDocument.getDefaultLevel() and\n"
		"SBMLDocument.getDefaultVersion(); however, the SBMLDocument object is\n"
		"otherwise left blank.  In particular, the blank SBMLDocument object\n"
		"has no associated XML attributes, including (but not limited to) an\n"
		"XML namespace declaration.  The XML namespace declaration is not added\n"
		"until the model is written out, or the method\n"
		"SBMLDocument.setLevelAndVersion() is called.  This may be important to\n"
		"keep in mind if an application needs to add additional XML namespace\n"
		"declarations on the <sbml> element.  Application writers should either\n"
		"provide values for 'level' and 'version' on the call to this\n"
		"constructor, or else call SBMLDocument.setLevelAndVersion() shortly\n"
		"after creating the SBMLDocument object.\n"
		"\n"
		"Parameter 'level' is an integer for the SBML Level.\n"
		"\n"
		"Parameter 'version' is an integer for the Version within the SBML\n"
		"Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"See also SBMLDocument.setLevelAndVersion(), getDefaultLevel(),\n"
		"getDefaultVersion().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLDocument(SBMLDocument orig)\n"
		"\n"
		"Copy constructor; creates a copy of this SBMLDocument.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "SBMLDocument_clone", _wrap_SBMLDocument_clone, METH_O, "\n"
		"SBMLDocument_clone(SBMLDocument self) -> SBMLDocument\n"
		"\n"
		"Creates and returns a deep copy of this SBMLDocument object.\n"
		"\n"
		"Returns the (deep) copy of this SBMLDocument object.\n"
		"\n"
		""},
	 { "SBMLDocument_isSetModel", _wrap_SBMLDocument_isSetModel, METH_O, "\n"
		"SBMLDocument_isSetModel(SBMLDocument self) -> bool\n"
		"\n"
		"Returns 'True' if the Model object has been set, otherwise  returns\n"
		"'False.'\n"
		"\n"
		"Returns 'True' if the Model object has been set\n"
		"\n"
		""},
	 { "SBMLDocument_getModel", _wrap_SBMLDocument_getModel, METH_VARARGS, "\n"
		"SBMLDocument_getModel(SBMLDocument self) -> Model\n"
		"SBMLDocument_getModel(SBMLDocument self) -> Model\n"
		"\n"
		"Returns the Model object stored in this SBMLDocument.\n"
		"\n"
		"It is important to note that this method does not create a Model\n"
		"instance.  The model in the SBMLDocument must have been created at\n"
		"some prior time, for example using SBMLDocument.createModel()  or\n"
		"SBMLDocument.setModel(). This method returns 'None' if a model does\n"
		"not yet exist.\n"
		"\n"
		"Returns the Model contained in this SBMLDocument, or 'None' if no such\n"
		"model exists.\n"
		"\n"
		"See also createModel().\n"
		"\n"
		""},
	 { "SBMLDocument_getElementBySId", _wrap_SBMLDocument_getElementBySId, METH_VARARGS, "\n"
		"SBMLDocument_getElementBySId(SBMLDocument self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given 'id' in the\n"
		"model-wide SId namespace, or 'None' if no such object is found.\n"
		"\n"
		"Parameter 'id' is string representing the id of the object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'id'.\n"
		"\n"
		""},
	 { "SBMLDocument_getElementByMetaId", _wrap_SBMLDocument_getElementByMetaId, METH_VARARGS, "\n"
		"SBMLDocument_getElementByMetaId(SBMLDocument self, string metaid) -> SBase\n"
		"\n"
		"Returns the first child element it can find with the given 'metaid',\n"
		"or itself if it has the given 'metaid', or 'None' if no such object is\n"
		"found.\n"
		"\n"
		"Parameter 'metaid' is string representing the metaid of the object to\n"
		"find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'metaid'.\n"
		"\n"
		""},
	 { "SBMLDocument_expandFunctionDefinitions", _wrap_SBMLDocument_expandFunctionDefinitions, METH_O, "\n"
		"SBMLDocument_expandFunctionDefinitions(SBMLDocument self) -> bool\n"
		"\n"
		"Removes FunctionDefinition constructs from the document and expands\n"
		"any instances of their use within <math> elements.\n"
		"\n"
		"For example, suppose a Model contains a FunctionDefinition with\n"
		"identifier ''f'' representing the math expression: f(x, y) = x * y.\n"
		"Suppose further that there is a reaction in which the <math> element\n"
		"of the KineticLaw object contains f(s, p), where 's' and 'p' are other\n"
		"identifiers defined in the model.  The outcome of invoking this method\n"
		"is that the <math> of the KineticLaw now represents the expression s *\n"
		"p and the model no longer contains any FunctionDefinition objects.\n"
		"\n"
		"Returns bool 'True' if the transformation was successful,  'False,'\n"
		"otherwise.\n"
		"\n"
		"Note: This function will check the consistency of a model before\n"
		"attemptimg the transformation.  If the model is not valid SBML, the\n"
		"transformation will not be performed and the function will return\n"
		"'False.'\n"
		"\n"
		""},
	 { "SBMLDocument_expandInitialAssignments", _wrap_SBMLDocument_expandInitialAssignments, METH_O, "\n"
		"SBMLDocument_expandInitialAssignments(SBMLDocument self) -> bool\n"
		"\n"
		"Removes InitialAssignment constructs from the document and replaces\n"
		"them with appropriate values.\n"
		"\n"
		"For example, suppose a Model contains a InitialAssignment to a symbol\n"
		"''k'' where ''k'' is the identifier of a Parameter.  The outcome of\n"
		"invoking this method is that the 'value' attribute of the Parameter\n"
		"definition is set to the result calculated using the InitialAssignment\n"
		"object's <math> formula, and the corresponding InitialAssignment is\n"
		"then removed from the Model.\n"
		"\n"
		"Returns bool 'True' if the transformation was successful,  'False,'\n"
		"otherwise.\n"
		"\n"
		"Note: This function will check the consistency of a model before\n"
		"attemptimg the transformation.  If the model is not valid SBML, the\n"
		"transformation will not be performed and the function will return\n"
		"'False.'  As part of that process, this method will check that it has\n"
		"values for any components referred to by the <math> elements of\n"
		"InitialAssignment objects.  In cases where not all of the values have\n"
		"been declared (e.g., if the mathematical expression refers to model\n"
		"entities that have no declared values), the InitialAssignment in\n"
		"question will not be removed and this method will return 'False.'\n"
		"\n"
		""},
	 { "SBMLDocument_setLevelAndVersion", _wrap_SBMLDocument_setLevelAndVersion, METH_VARARGS, "\n"
		"SBMLDocument_setLevelAndVersion(SBMLDocument self, unsigned int level, unsigned int version, bool strict=True, bool ignorePackages=False) -> bool\n"
		"\n"
		"Sets the SBML Level and Version of this SBMLDocument instance,\n"
		"attempting to convert the model as needed.\n"
		"\n"
		"This method is the principal way in libSBML to convert models between\n"
		"Levels and Versions of SBML.  Generally, models can be converted\n"
		"upward without difficulty (e.g., from SBML Level 1 to Level 2, or from\n"
		"an earlier Version of Level 2 to the latest Version of Level 2).\n"
		"Sometimes models can be translated downward as well, if they do not\n"
		"use constructs specific to more advanced Levels of SBML.\n"
		"\n"
		"Before calling this method, callers may check compatibility directly\n"
		"using the methods SBMLDocument.checkL1Compatibility(),\n"
		"SBMLDocument.checkL2v1Compatibility(),\n"
		"SBMLDocument.checkL2v2Compatibility(),\n"
		"SBMLDocument.checkL2v3Compatibility(),\n"
		"SBMLDocument.checkL2v4Compatibility(),\n"
		"SBMLDocument.checkL2v5Compatibility(),\n"
		"SBMLDocument.checkL3v1Compatibility(), and\n"
		"SBMLDocument.checkL3v2Compatibility().\n"
		"\n"
		"The valid combinations of SBML Level and Version as of this release of\n"
		"libSBML are the following:\n"
		"\n"
		"* Level 1 Version 2\n"
		"\n"
		"* Level 2 Version 1\n"
		"\n"
		"* Level 2 Version 2\n"
		"\n"
		"* Level 2 Version 3\n"
		"\n"
		"* Level 2 Version 4\n"
		"\n"
		"* Level 2 Version 5\n"
		"\n"
		"* Level 3 Version 1\n"
		"\n"
		"* Level 3 Version 2 Strict conversion applies the additional\n"
		"criteria that both the source and the target model must be consistent\n"
		"SBML.  Users can control the consistency checks that are applied using\n"
		"the SBMLDocument.setConsistencyChecksForConversion() method.  If\n"
		"either the source or the potential target model have validation\n"
		"errors, the conversion is not performed.  When a strict conversion is\n"
		"successful, the underlying SBML object model is altered to reflect the\n"
		"new level and version.  Thus, information that cannot be converted\n"
		"(e.g. sboTerms) will be lost.\n"
		"\n"
		"Parameter 'level' is the desired SBML Level.\n"
		"\n"
		"Parameter 'version' is the desired Version within the SBML Level.\n"
		"\n"
		"Parameter 'strict' is boolean indicating whether to check consistency\n"
		"of both the source and target model when performing conversion\n"
		"(defaults to  true ).\n"
		"\n"
		"Parameter 'ignorePackages' is boolean indicating whether the presence\n"
		"of packages should be ignored by the conversion routine  (defaults to\n"
		"false ).\n"
		"\n"
		"Returns 'True' if the level and version of the document were\n"
		"successfully set to the requested values (which may have required\n"
		"conversion of the model), 'False' otherwise.\n"
		"\n"
		"Note: Calling this method will not necessarily lead to a successful\n"
		"conversion.  If the conversion fails, it will be logged in the error\n"
		"list associated with this SBMLDocument.  Callers should consult\n"
		"getNumErrors() to find out if the conversion succeeded without\n"
		"problems.  For conversions from Level 2 to Level 1, callers can also\n"
		"check the Level of the model after calling this method to find out\n"
		"whether it is Level 1.  (If the conversion to Level 1 failed, the\n"
		"Level of this model will be left unchanged.)\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"See also checkL1Compatibility(), checkL2v1Compatibility(),\n"
		"checkL2v2Compatibility(), checkL2v3Compatibility(),\n"
		"checkL2v4Compatibility(), checkL2v5Compatibility(),\n"
		"checkL3v1Compatibility().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SBMLDocument_updateSBMLNamespace", _wrap_SBMLDocument_updateSBMLNamespace, METH_VARARGS, "\n"
		"SBMLDocument_updateSBMLNamespace(SBMLDocument self, string package, unsigned int level, unsigned int version)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_setModel", _wrap_SBMLDocument_setModel, METH_VARARGS, "\n"
		"SBMLDocument_setModel(SBMLDocument self, Model m) -> int\n"
		"\n"
		"Sets the Model for this SBMLDocument to a copy of the given Model.\n"
		"\n"
		"Parameter 'm' is the new Model to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"See also createModel(), getModel().\n"
		"\n"
		""},
	 { "SBMLDocument_createModel", _wrap_SBMLDocument_createModel, METH_VARARGS, "\n"
		"SBMLDocument_createModel(SBMLDocument self, string sid=\"\") -> Model\n"
		"\n"
		"Creates a new Model inside this SBMLDocument, and returns a pointer to\n"
		"it.\n"
		"\n"
		"In SBML Level 2, the use of an identifier on a Model object is\n"
		"optional.  This method takes an optional argument, 'sid', for setting\n"
		"the identifier.  If not supplied, the identifier attribute on the\n"
		"Model instance is not set.\n"
		"\n"
		"Parameter 'sid' is the identifier of the new Model to create.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"See also getModel(), SBMLDocument.setModel().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SBMLDocument_setLocationURI", _wrap_SBMLDocument_setLocationURI, METH_VARARGS, "\n"
		"SBMLDocument_setLocationURI(SBMLDocument self, string uri)\n"
		"\n"
		"Sets the location of this SBMLDocument.\n"
		"\n"
		"Called automatically when readSBMLFromFile is used, but may be set\n"
		"manually as well.\n"
		"\n"
		""},
	 { "SBMLDocument_getLocationURI", _wrap_SBMLDocument_getLocationURI, METH_VARARGS, "\n"
		"SBMLDocument_getLocationURI(SBMLDocument self) -> string\n"
		"SBMLDocument_getLocationURI(SBMLDocument self) -> string\n"
		"\n"
		"Get the location of this SBMLDocument.\n"
		"\n"
		"If this document was read from a file or had its location set\n"
		"manually, that filename or set location will be returned, otherwise,\n"
		"an empty string is returned.\n"
		"\n"
		""},
	 { "SBMLDocument_setConsistencyChecks", _wrap_SBMLDocument_setConsistencyChecks, METH_VARARGS, "\n"
		"SBMLDocument_setConsistencyChecks(SBMLDocument self, SBMLErrorCategory_t category, bool apply)\n"
		"\n"
		"Controls the consistency checks that are performed when\n"
		"SBMLDocument.checkConsistency() is called.\n"
		"\n"
		"This method works by adding or subtracting consistency checks from the\n"
		"set of all possible checks that SBMLDocument.checkConsistency() knows\n"
		"how to perform.  This method may need to be called multiple times in\n"
		"order to achieve the desired combination of checks.  The first\n"
		"argument ('category') in a call to this method indicates the category\n"
		"of consistency/error checks that are to be turned on or off, and the\n"
		"second argument ('apply', a boolean) indicates whether to turn it on\n"
		"(value of 'True)' or off (value of 'False).'\n"
		"\n"
		"The possible categories (values to the argument 'category') are the\n"
		"set of constants whose names begin with the characters LIBSBML_CAT_ in\n"
		"the interface class libsbml. The following are the possible choices:\n"
		"\n"
		"* LIBSBML_CAT_GENERAL_CONSISTENCY: Correctness and consistency of\n"
		"specific SBML language constructs. Performing this set of checks is\n"
		"highly recommended.  With respect to the SBML specification, these\n"
		"concern failures in applying the validation rules numbered 2xxxx in\n"
		"the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.\n"
		"\n"
		"* LIBSBML_CAT_IDENTIFIER_CONSISTENCY: Correctness and consistency of\n"
		"identifiers used for model entities.  An example of inconsistency\n"
		"would be using a species identifier in a reaction rate formula without\n"
		"first having declared the species.  With respect to the SBML\n"
		"specification, these concern failures in applying the validation rules\n"
		"numbered 103xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2\n"
		"specifications.\n"
		"\n"
		"* LIBSBML_CAT_UNITS_CONSISTENCY: Consistency of measurement units\n"
		"associated with quantities in a model. With respect to the SBML\n"
		"specification, these concern failures in applying the validation rules\n"
		"numbered 105xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2\n"
		"specifications.\n"
		"\n"
		"* LIBSBML_CAT_MATHML_CONSISTENCY: Syntax of MathML constructs.  With\n"
		"respect to the SBML specification, these concern failures in applying\n"
		"the validation rules numbered 102xx in the Level 2 Versions 2-4 and\n"
		"Level 3 Versions 1-2 specifications.\n"
		"\n"
		"* LIBSBML_CAT_SBO_CONSISTENCY: Consistency and validity of SBO\n"
		"identifiers (if any) used in the model. With respect to the SBML\n"
		"specification, these concern failures in applying the validation rules\n"
		"numbered 107xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2\n"
		"specifications.\n"
		"\n"
		"* LIBSBML_CAT_OVERDETERMINED_MODEL: Static analysis of whether the\n"
		"system of equations implied by a model is mathematically\n"
		"overdetermined.  With respect to the SBML specification, this is\n"
		"validation rule #10601 in the Level 2 Versions 2-4 and Level 3\n"
		"Versions 1-2 specifications.\n"
		"\n"
		"* LIBSBML_CAT_MODELING_PRACTICE: Additional checks for recommended\n"
		"good modeling practice. (These are tests performed by libSBML and do\n"
		"not have equivalent SBML validation rules.)  By default, all\n"
		"validation checks are applied to the model in an SBMLDocument object\n"
		"unless SBMLDocument.setConsistencyChecks() is called to indicate that\n"
		"only a subset should be applied.  Further, this default (i.e.,\n"
		"performing all checks) applies separately to each new SBMLDocument\n"
		"object created.  In other words, each time a model is read using\n"
		"SBMLReader.readSBML(), SBMLReader.readSBMLFromString(), or the global\n"
		"functions readSBML() and readSBMLFromString(), a new SBMLDocument is\n"
		"created and for that document, a call to\n"
		"SBMLDocument.checkConsistency() will default to applying all possible\n"
		"checks. Calling programs must invoke\n"
		"SBMLDocument.setConsistencyChecks() for each such new model if they\n"
		"wish to change the consistency checks applied.\n"
		"\n"
		"Parameter 'category' is a value drawn from the set of SBML error\n"
		"categories indicating the consistency checking/validation to be turned\n"
		"on or off.\n"
		"\n"
		"Parameter 'apply' is a boolean indicating whether the checks indicated\n"
		"by 'category' should be applied or not.\n"
		"\n"
		"See also SBMLDocument.checkConsistency().\n"
		"\n"
		""},
	 { "SBMLDocument_setConsistencyChecksForConversion", _wrap_SBMLDocument_setConsistencyChecksForConversion, METH_VARARGS, "\n"
		"SBMLDocument_setConsistencyChecksForConversion(SBMLDocument self, SBMLErrorCategory_t category, bool apply)\n"
		"\n"
		"Controls the consistency checks that are performed when\n"
		"SBMLDocument.setLevelAndVersion() is called.\n"
		"\n"
		"This method works by adding or subtracting consistency checks from the\n"
		"set of all possible checks that may be performed to avoid conversion\n"
		"to or from an invalid document.  This method may need to be called\n"
		"multiple times in order to achieve the desired combination of checks.\n"
		"The first argument ('category') in a call to this method indicates the\n"
		"category of consistency/error checks that are to be turned on or off,\n"
		"and the second argument ('apply', a boolean) indicates whether to turn\n"
		"it on (value of 'True)' or off (value of 'False).'\n"
		"\n"
		"The possible categories (values to the argument 'category') are the\n"
		"set of constants whose names begin with the characters LIBSBML_CAT_ in\n"
		"the interface class libsbml. The following are the possible choices:\n"
		"\n"
		"* LIBSBML_CAT_GENERAL_CONSISTENCY: Correctness and consistency of\n"
		"specific SBML language constructs. Performing this set of checks is\n"
		"highly recommended.  With respect to the SBML specification, these\n"
		"concern failures in applying the validation rules numbered 2xxxx in\n"
		"the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.\n"
		"\n"
		"* LIBSBML_CAT_IDENTIFIER_CONSISTENCY: Correctness and consistency of\n"
		"identifiers used for model entities.  An example of inconsistency\n"
		"would be using a species identifier in a reaction rate formula without\n"
		"first having declared the species.  With respect to the SBML\n"
		"specification, these concern failures in applying the validation rules\n"
		"numbered 103xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2\n"
		"specifications.\n"
		"\n"
		"* LIBSBML_CAT_UNITS_CONSISTENCY: Consistency of measurement units\n"
		"associated with quantities in a model. With respect to the SBML\n"
		"specification, these concern failures in applying the validation rules\n"
		"numbered 105xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2\n"
		"specifications.\n"
		"\n"
		"* LIBSBML_CAT_MATHML_CONSISTENCY: Syntax of MathML constructs.  With\n"
		"respect to the SBML specification, these concern failures in applying\n"
		"the validation rules numbered 102xx in the Level 2 Versions 2-4 and\n"
		"Level 3 Versions 1-2 specifications.\n"
		"\n"
		"* LIBSBML_CAT_SBO_CONSISTENCY: Consistency and validity of SBO\n"
		"identifiers (if any) used in the model. With respect to the SBML\n"
		"specification, these concern failures in applying the validation rules\n"
		"numbered 107xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2\n"
		"specifications.\n"
		"\n"
		"* LIBSBML_CAT_OVERDETERMINED_MODEL: Static analysis of whether the\n"
		"system of equations implied by a model is mathematically\n"
		"overdetermined.  With respect to the SBML specification, this is\n"
		"validation rule #10601 in the Level 2 Versions 2-4 and Level 3\n"
		"Versions 1-2 specifications.\n"
		"\n"
		"* LIBSBML_CAT_MODELING_PRACTICE: Additional checks for recommended\n"
		"good modeling practice. (These are tests performed by libSBML and do\n"
		"not have equivalent SBML validation rules.) By default, all validation\n"
		"checks are applied to the model in an SBMLDocument object unless\n"
		"SBMLDocument.setConsistencyChecks() is called to indicate that only a\n"
		"subset should be applied.  Further, this default (i.e., performing all\n"
		"checks) applies separately to each new SBMLDocument object created.\n"
		"In other words, each time a model is read using SBMLReader.readSBML(),\n"
		"SBMLReader.readSBMLFromString(), or the global functions readSBML()\n"
		"and readSBMLFromString(), a new SBMLDocument is created and for that\n"
		"document, a call to SBMLDocument.checkConsistency() will default to\n"
		"applying all possible checks. Calling programs must invoke\n"
		"SBMLDocument.setConsistencyChecks() for each such new model if they\n"
		"wish to change the consistency checks applied.\n"
		"\n"
		"Parameter 'category' is a value drawn from the set of SBML error\n"
		"categories indicating the consistency checking/validation to be turned\n"
		"on or off.\n"
		"\n"
		"Parameter 'apply' is a boolean indicating whether the checks indicated\n"
		"by 'category' should be applied or not.\n"
		"\n"
		"See also SBMLDocument.setLevelAndVersion().\n"
		"\n"
		""},
	 { "SBMLDocument_checkConsistency", _wrap_SBMLDocument_checkConsistency, METH_O, "\n"
		"SBMLDocument_checkConsistency(SBMLDocument self) -> unsigned int\n"
		"\n"
		"Performs consistency checking and validation on this SBML document.\n"
		"\n"
		"If this method returns a nonzero value (meaning, one or more\n"
		"consistency checks have failed for SBML document), the failures may be\n"
		"due to warnings or errors.  Callers should inspect the severity flag\n"
		"in the individual SBMLError objects returned by\n"
		"SBMLDocument.getError() to determine the nature of the failures.\n"
		"\n"
		"Returns the number of failed checks (errors) encountered.\n"
		"\n"
		"See also SBMLDocument.checkInternalConsistency().\n"
		"\n"
		""},
	 { "SBMLDocument_checkConsistencyWithStrictUnits", _wrap_SBMLDocument_checkConsistencyWithStrictUnits, METH_O, "\n"
		"SBMLDocument_checkConsistencyWithStrictUnits(SBMLDocument self) -> unsigned int\n"
		"\n"
		"Performs consistency checking and validation on this SBML document\n"
		"using the ultra strict units validator that assumes that there are no\n"
		"hidden numerical conversion factors.\n"
		"\n"
		"If this method returns a nonzero value (meaning, one or more\n"
		"consistency checks have failed for SBML document), the failures may be\n"
		"due to warnings or errors.  Callers should inspect the severity flag\n"
		"in the individual SBMLError objects returned by\n"
		"SBMLDocument.getError() to determine the nature of the failures.\n"
		"\n"
		"Returns the number of failed checks (errors) encountered.\n"
		"\n"
		"See also SBMLDocument.checkInternalConsistency().\n"
		"\n"
		""},
	 { "SBMLDocument_validateSBML", _wrap_SBMLDocument_validateSBML, METH_O, "\n"
		"SBMLDocument_validateSBML(SBMLDocument self) -> unsigned int\n"
		"\n"
		"Performs consistency checking and validation on this SBML document.\n"
		"\n"
		"If this method returns a nonzero value (meaning, one or more\n"
		"consistency checks have failed for SBML document), the failures may be\n"
		"due to warnings or errors.  Callers should inspect the severity flag\n"
		"in the individual SBMLError objects returned by\n"
		"SBMLDocument.getError() to determine the nature of the failures.\n"
		"\n"
		"Note: unlike checkConsistency this method will write the document in\n"
		"order to determine all errors for the document. This will  also clear\n"
		"the error log.\n"
		"\n"
		"Returns the number of failed checks (errors) encountered.\n"
		"\n"
		"See also SBMLDocument.checkConsistency().\n"
		"\n"
		""},
	 { "SBMLDocument_checkInternalConsistency", _wrap_SBMLDocument_checkInternalConsistency, METH_O, "\n"
		"SBMLDocument_checkInternalConsistency(SBMLDocument self) -> unsigned int\n"
		"\n"
		"Performs consistency checking on libSBML's internal representation of\n"
		"an SBML Model.\n"
		"\n"
		"Callers should query the results of the consistency check by calling\n"
		"SBMLDocument.getError().\n"
		"\n"
		"Returns the number of failed checks (errors) encountered.\n"
		"\n"
		"The distinction between this method and\n"
		"SBMLDocument.checkConsistency() is that this method reports on\n"
		"fundamental syntactic and structural errors that violate the XML\n"
		"Schema for SBML; by contrast, SBMLDocument.checkConsistency() performs\n"
		"more elaborate model verifications and also validation according to\n"
		"the validation rules written in the appendices of the SBML Level 2\n"
		"Versions 2-4 specification documents.\n"
		"\n"
		"See also SBMLDocument.checkConsistency().\n"
		"\n"
		""},
	 { "SBMLDocument_checkL1Compatibility", _wrap_SBMLDocument_checkL1Compatibility, METH_VARARGS, "\n"
		"SBMLDocument_checkL1Compatibility(SBMLDocument self, bool inConversion=False) -> unsigned int\n"
		"\n"
		"Performs a set of consistency checks on the document to establish\n"
		"whether it is compatible with SBML Level 1 and can be converted to\n"
		"Level 1.\n"
		"\n"
		"Callers should query the results of the consistency check by calling\n"
		"SBMLDocument.getError().\n"
		"\n"
		"Returns the number of failed checks (errors) encountered.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SBMLDocument_checkL2v1Compatibility", _wrap_SBMLDocument_checkL2v1Compatibility, METH_VARARGS, "\n"
		"SBMLDocument_checkL2v1Compatibility(SBMLDocument self, bool inConversion=False) -> unsigned int\n"
		"\n"
		"Performs a set of consistency checks on the document to establish\n"
		"whether it is compatible with SBML Level 2 Version 1 and can be\n"
		"converted to Level 2 Version 1.\n"
		"\n"
		"Callers should query the results of the consistency check by calling\n"
		"SBMLDocument.getError().\n"
		"\n"
		"Returns the number of failed checks (errors) encountered.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SBMLDocument_checkL2v2Compatibility", _wrap_SBMLDocument_checkL2v2Compatibility, METH_VARARGS, "\n"
		"SBMLDocument_checkL2v2Compatibility(SBMLDocument self, bool inConversion=False) -> unsigned int\n"
		"\n"
		"Performs a set of consistency checks on the document to establish\n"
		"whether it is compatible with SBML Level 2 Version 2 and can be\n"
		"converted to Level 2 Version 2.\n"
		"\n"
		"Callers should query the results of the consistency check by calling\n"
		"SBMLDocument.getError().\n"
		"\n"
		"Returns the number of failed checks (errors) encountered.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SBMLDocument_checkL2v3Compatibility", _wrap_SBMLDocument_checkL2v3Compatibility, METH_VARARGS, "\n"
		"SBMLDocument_checkL2v3Compatibility(SBMLDocument self, bool inConversion=False) -> unsigned int\n"
		"\n"
		"Performs a set of consistency checks on the document to establish\n"
		"whether it is compatible with SBML Level 2 Version 3 and can be\n"
		"converted to Level 2 Version 3.\n"
		"\n"
		"Callers should query the results of the consistency check by calling\n"
		"SBMLDocument.getError().\n"
		"\n"
		"Returns the number of failed checks (errors) encountered.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SBMLDocument_checkL2v4Compatibility", _wrap_SBMLDocument_checkL2v4Compatibility, METH_O, "\n"
		"SBMLDocument_checkL2v4Compatibility(SBMLDocument self) -> unsigned int\n"
		"\n"
		"Performs a set of consistency checks on the document to establish\n"
		"whether it is compatible with SBML Level 2 Version 4 and can be\n"
		"converted to Level 2 Version 4.\n"
		"\n"
		"Callers should query the results of the consistency check by calling\n"
		"SBMLDocument.getError().\n"
		"\n"
		"Returns the number of failed checks (errors) encountered.\n"
		"\n"
		""},
	 { "SBMLDocument_checkL2v5Compatibility", _wrap_SBMLDocument_checkL2v5Compatibility, METH_O, "\n"
		"SBMLDocument_checkL2v5Compatibility(SBMLDocument self) -> unsigned int\n"
		"\n"
		"Performs a set of consistency checks on the document to establish\n"
		"whether it is compatible with SBML Level 2 Version 5 and can be\n"
		"converted to Level 2 Version 5.\n"
		"\n"
		"Callers should query the results of the consistency check by calling\n"
		"SBMLDocument.getError().\n"
		"\n"
		"Returns the number of failed checks (errors) encountered.\n"
		"\n"
		""},
	 { "SBMLDocument_checkL3v1Compatibility", _wrap_SBMLDocument_checkL3v1Compatibility, METH_O, "\n"
		"SBMLDocument_checkL3v1Compatibility(SBMLDocument self) -> unsigned int\n"
		"\n"
		"Performs a set of consistency checks on the document to establish\n"
		"whether it is compatible with SBML Level 3 Version 1 and can be\n"
		"converted to Level 3 Version 1.\n"
		"\n"
		"Callers should query the results of the consistency check by calling\n"
		"SBMLDocument.getError().\n"
		"\n"
		"Returns the number of failed checks (errors) encountered.\n"
		"\n"
		""},
	 { "SBMLDocument_checkL3v2Compatibility", _wrap_SBMLDocument_checkL3v2Compatibility, METH_O, "\n"
		"SBMLDocument_checkL3v2Compatibility(SBMLDocument self) -> unsigned int\n"
		"\n"
		"Performs a set of consistency checks on the document to establish\n"
		"whether it is compatible with SBML Level 3 Version 2 and can be\n"
		"converted to Level 3 Version 2.\n"
		"\n"
		"Callers should query the results of the consistency check by calling\n"
		"SBMLDocument.getError().\n"
		"\n"
		"Returns the number of failed checks (errors) encountered.\n"
		"\n"
		""},
	 { "SBMLDocument_getError", _wrap_SBMLDocument_getError, METH_VARARGS, "\n"
		"SBMLDocument_getError(SBMLDocument self, unsigned int n) -> SBMLError\n"
		"\n"
		"Returns the nth error or warning encountered during parsing,\n"
		"consistency checking, or attempted translation of this model.\n"
		"\n"
		"Callers can use method XMLError.getSeverity() on the result to assess\n"
		"the severity of the problem.  The possible severity levels range from\n"
		"informational messages to fatal errors.\n"
		"\n"
		"Returns the error or warning indexed by integer 'n', or return 'None'\n"
		"if n > (getNumErrors() - 1).\n"
		"\n"
		"Parameter 'n' is the integer index of the error sought.\n"
		"\n"
		"See also SBMLDocument.getNumErrors().\n"
		"\n"
		""},
	 { "SBMLDocument_getErrorWithSeverity", _wrap_SBMLDocument_getErrorWithSeverity, METH_VARARGS, "\n"
		"SBMLDocument_getErrorWithSeverity(SBMLDocument self, unsigned int n, unsigned int severity) -> SBMLError\n"
		"\n"
		"Returns the nth error or warning with the given severity encountered\n"
		"during parsing, consistency checking, or attempted translation of this\n"
		"model.\n"
		"\n"
		"Returns the error or warning indexed by integer 'n', or return 'None'\n"
		"if n > (getNumErrors(severity) - 1).\n"
		"\n"
		"Parameter 'n' is the integer index of the error sought. Parameter\n"
		"'severity' is the severity of the error sought.\n"
		"\n"
		"See also SBMLDocument.getNumErrors().\n"
		"\n"
		""},
	 { "SBMLDocument_getNumErrors", _wrap_SBMLDocument_getNumErrors, METH_VARARGS, "\n"
		"SBMLDocument_getNumErrors(SBMLDocument self) -> unsigned int\n"
		"SBMLDocument_getNumErrors(SBMLDocument self, unsigned int severity) -> unsigned int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getNumErrors(long severity)\n"
		"\n"
		"Returns the number of errors or warnings encountered with the given\n"
		"severity during parsing, consistency checking, or attempted\n"
		"translation of this model.\n"
		"\n"
		"Parameter 'severity' is the severity of the error sought.\n"
		"\n"
		"Returns the number of errors or warnings encountered.\n"
		"\n"
		"See also SBMLDocument.getError().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getNumErrors()\n"
		"\n"
		"Returns the number of errors or warnings encountered during parsing,\n"
		"consistency checking, or attempted translation of this model.\n"
		"\n"
		"Returns the number of errors or warnings encountered.\n"
		"\n"
		"See also SBMLDocument.getError().\n"
		"\n"
		""},
	 { "SBMLDocument_printErrors", _wrap_SBMLDocument_printErrors, METH_VARARGS, "\n"
		"SBMLDocument_printErrors(SBMLDocument self, ostream stream=cerr)\n"
		"SBMLDocument_printErrors(SBMLDocument self, ostream stream, unsigned int severity)\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    printErrors(std::ostream stream, long severity)\n"
		"\n"
		"Prints all the errors or warnings with the given severity encountered\n"
		"trying to parse, check, or translate this SBML document.\n"
		"\n"
		"It prints the text to the stream given by the parameter 'stream'.\n"
		"\n"
		"If no errors have occurred, i.e., getNumErrors(severity) == 0, no\n"
		"output will be sent to the stream.\n"
		"\n"
		"The format of the output is:\n"
		"\n"
		"      N error(s):\n"
		"        line NNN: (id) message\n"
		"\n"
		"Parameter 'stream' is the ostream or ostringstream object indicating\n"
		"where the output should be printed. Parameter 'severity' is of the\n"
		"errors sought.\n"
		"\n"
		"See also getNumErrors(), getErrorLog(),\n"
		"SBMLDocument.getErrorWithSeverity().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    printErrors(std::ostream stream = std::cerr)\n"
		"\n"
		"Prints all the errors or warnings encountered trying to parse, check,\n"
		"or translate this SBML document.\n"
		"\n"
		"It prints the text to the stream given by the optional parameter\n"
		"'stream'.  If no parameter is given, it prints the output to the\n"
		"standard error stream.\n"
		"\n"
		"If no errors have occurred, i.e., getNumErrors() == 0, no output will\n"
		"be sent to the stream.\n"
		"\n"
		"The format of the output is:\n"
		"\n"
		"     N error(s):\n"
		"       line NNN: (id) message\n"
		"\n"
		"Parameter 'stream' is the ostream or ostringstream object indicating\n"
		"where the output should be printed.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"See also getNumErrors(), getErrorLog(), SBMLDocument.getError().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SBMLDocument_connectToChild", _wrap_SBMLDocument_connectToChild, METH_O, "SBMLDocument_connectToChild(SBMLDocument self)"},
	 { "SBMLDocument_convert", _wrap_SBMLDocument_convert, METH_VARARGS, "\n"
		"SBMLDocument_convert(SBMLDocument self, ConversionProperties props) -> int\n"
		"\n"
		"Converts this document using the converter that best matches the given\n"
		"conversion properties.\n"
		"\n"
		"Parameter 'props' is the conversion properties to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_CONV_CONVERSION_NOT_AVAILABLE\n"
		"\n"
		""},
	 { "SBMLDocument_enablePackageInternal", _wrap_SBMLDocument_enablePackageInternal, METH_VARARGS, "\n"
		"SBMLDocument_enablePackageInternal(SBMLDocument self, string pkgURI, string pkgPrefix, bool flag)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_getTypeCode", _wrap_SBMLDocument_getTypeCode, METH_O, "\n"
		"SBMLDocument_getTypeCode(SBMLDocument self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_DOCUMENT (default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also SBMLDocument.getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "SBMLDocument_getElementName", _wrap_SBMLDocument_getElementName, METH_O, "\n"
		"SBMLDocument_getElementName(SBMLDocument self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for SBMLDocument,\n"
		"is always ''sbml'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''sbml'.'\n"
		"\n"
		""},
	 { "SBMLDocument_getErrorLog", _wrap_SBMLDocument_getErrorLog, METH_VARARGS, "\n"
		"SBMLDocument_getErrorLog(SBMLDocument self) -> SBMLErrorLog\n"
		"SBMLDocument_getErrorLog(SBMLDocument self) -> SBMLErrorLog\n"
		"\n"
		"Returns the list of errors or warnings logged during parsing,\n"
		"consistency checking, or attempted translation of this model.\n"
		"\n"
		"Returns the SBMLErrorLog used for this SBMLDocument.\n"
		"\n"
		"See also SBMLDocument.getNumErrors().\n"
		"\n"
		""},
	 { "SBMLDocument_getNamespaces", _wrap_SBMLDocument_getNamespaces, METH_O, "\n"
		"SBMLDocument_getNamespaces(SBMLDocument self) -> XMLNamespaces\n"
		"\n"
		"Returns a list of XML Namespaces associated with the XML content of\n"
		"this SBML document.\n"
		"\n"
		"Returns the XML Namespaces associated with this SBML object.\n"
		"\n"
		""},
	 { "SBMLDocument_enableDefaultNS", _wrap_SBMLDocument_enableDefaultNS, METH_VARARGS, "\n"
		"SBMLDocument_enableDefaultNS(SBMLDocument self, string package, bool flag) -> int\n"
		"\n"
		"Set/unset default namespace to each top-level element defined in the\n"
		"given package extension.\n"
		"\n"
		"This works by adding a xmlns=\"...\" attribute.  No prefix will be\n"
		"written when writing elements defined in the given package extension\n"
		"if 'True' is given as second argument.\n"
		"\n"
		"Parameter 'package' is the name or URI of the package extension.\n"
		"Parameter 'flag' is boolean value to indicate whether to write a\n"
		"namespace prefix.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_PKG_UNKNOWN_VERSION\n"
		"\n"
		""},
	 { "SBMLDocument_isEnabledDefaultNS", _wrap_SBMLDocument_isEnabledDefaultNS, METH_VARARGS, "\n"
		"SBMLDocument_isEnabledDefaultNS(SBMLDocument self, string package) -> bool\n"
		"\n"
		"Returns 'True' if a default namespace is added to each top-level\n"
		"element defined in the given package extension, otherwise returns\n"
		"'False.'\n"
		"\n"
		"This basically checks if the attribute xmlns=\"...\" is present.\n"
		"\n"
		"Parameter 'package' is the name or URI of the package extension.\n"
		"\n"
		"Returns a boolean indicating whether the given package's default\n"
		"namespace is enabled.\n"
		"\n"
		""},
	 { "SBMLDocument_setPackageRequired", _wrap_SBMLDocument_setPackageRequired, METH_VARARGS, "\n"
		"SBMLDocument_setPackageRequired(SBMLDocument self, string package, bool flag) -> int\n"
		"\n"
		"Sets the required attribute value of the given package extension.\n"
		"\n"
		"Parameter 'package' is the name or URI of the package extension.\n"
		"Parameter 'flag' is Boolean value indicating whether the package is\n"
		"required.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_PKG_UNKNOWN_VERSION\n"
		"\n"
		""},
	 { "SBMLDocument_getPackageRequired", _wrap_SBMLDocument_getPackageRequired, METH_VARARGS, "\n"
		"SBMLDocument_getPackageRequired(SBMLDocument self, string package) -> bool\n"
		"\n"
		"Returns the required attribute of the given package extension.\n"
		"\n"
		"Parameter 'package' is the name or URI of the package extension.\n"
		"\n"
		"Returns Boolean flag indicating whether the package is flagged as\n"
		"being required.\n"
		"\n"
		""},
	 { "SBMLDocument_isSetPackageRequired", _wrap_SBMLDocument_isSetPackageRequired, METH_VARARGS, "\n"
		"SBMLDocument_isSetPackageRequired(SBMLDocument self, string package) -> bool\n"
		"\n"
		"Returns 'True' if the required attribute of the given package\n"
		"extension is defined, otherwise returns 'False.'\n"
		"\n"
		"Parameter 'package' is the name or URI of the package extension.\n"
		"\n"
		"Returns a Boolean indicating whether the package's 'required' flag is\n"
		"set.\n"
		"\n"
		""},
	 { "SBMLDocument_isIgnoredPackage", _wrap_SBMLDocument_isIgnoredPackage, METH_VARARGS, "\n"
		"SBMLDocument_isIgnoredPackage(SBMLDocument self, string pkgURI) -> bool\n"
		"\n"
		"Returns 'True' if the given package extension is one of an ignored\n"
		"packages, otherwise returns 'False.'\n"
		"\n"
		"An ignored package is one that is defined to be used in this SBML\n"
		"document, but the package is not enabled in this copy of libSBML.\n"
		"\n"
		"Parameter 'pkgURI' is the URI of the package extension.\n"
		"\n"
		"Returns a Boolean, 'True' if the package is being ignored and 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLDocument_isDisabledIgnoredPackage", _wrap_SBMLDocument_isDisabledIgnoredPackage, METH_VARARGS, "\n"
		"SBMLDocument_isDisabledIgnoredPackage(SBMLDocument self, string pkgURI) -> bool\n"
		"\n"
		"Returns 'True' if the given package extension is one of an ignored\n"
		"packages that has been disabled, otherwise returns 'False.'\n"
		"\n"
		"An ignored package is one that is defined to be used in this SBML\n"
		"document, but the package is not enabled in this copy of libSBML. It\n"
		"may have been disabled to avoid reproducing the package information\n"
		"when writing out the file.\n"
		"\n"
		"Parameter 'pkgURI' is the URI of the package extension.\n"
		"\n"
		"Returns a Boolean, 'True' if the package is being ignored and 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLDocument_setPkgRequired", _wrap_SBMLDocument_setPkgRequired, METH_VARARGS, "\n"
		"SBMLDocument_setPkgRequired(SBMLDocument self, string package, bool flag) -> int\n"
		"\n"
		"Sets the value of the required attribute for the given package.\n"
		"\n"
		"Parameter 'package' is the name or URI of the package extension.\n"
		"Parameter 'flag' is a Boolean value.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_PKG_UNKNOWN_VERSION\n"
		"\n"
		"DEPRECATED. Replaced in libSBML 5.2.0 by setPackageRequired()\n"
		"\n"
		""},
	 { "SBMLDocument_getPkgRequired", _wrap_SBMLDocument_getPkgRequired, METH_VARARGS, "\n"
		"SBMLDocument_getPkgRequired(SBMLDocument self, string package) -> bool\n"
		"\n"
		"Returns the required attribute of the given package extension.\n"
		"\n"
		"Parameter 'package' is the name or URI of the package extension.\n"
		"\n"
		"Returns a Boolean value indicating whether the package is flagged as\n"
		"being required in this SBML document.\n"
		"\n"
		"DEPRECATED. Replaced in libSBML 5.2.0 by getPackageRequired()\n"
		"\n"
		""},
	 { "SBMLDocument_isSetPkgRequired", _wrap_SBMLDocument_isSetPkgRequired, METH_VARARGS, "\n"
		"SBMLDocument_isSetPkgRequired(SBMLDocument self, string package) -> bool\n"
		"\n"
		"Returns 'True' if the required attribute of the given package\n"
		"extension is defined, otherwise returns 'False.'\n"
		"\n"
		"Parameter 'package' is the name or URI of the package extension.\n"
		"\n"
		"Returns a Boolean value.\n"
		"\n"
		"DEPRECATED. Replaced in libSBML 5.2.0 by isSetPackageRequired()\n"
		"\n"
		""},
	 { "SBMLDocument_isIgnoredPkg", _wrap_SBMLDocument_isIgnoredPkg, METH_VARARGS, "\n"
		"SBMLDocument_isIgnoredPkg(SBMLDocument self, string pkgURI) -> bool\n"
		"\n"
		"Returns 'True' if the given package extension is one of ignored\n"
		"packages, otherwise returns 'False.'\n"
		"\n"
		"An ignored package is one that is defined to be used in this SBML\n"
		"document, but the package is not enabled in this copy of libSBML.\n"
		"\n"
		"Parameter 'pkgURI' is the URI of the package extension.\n"
		"\n"
		"Returns a boolean indicating whether the given package is being\n"
		"ignored.\n"
		"\n"
		"DEPRECATED. Replaced in libSBML 5.2.0 by isIgnoredPackage()\n"
		"\n"
		""},
	 { "SBMLDocument_getApplicableValidators", _wrap_SBMLDocument_getApplicableValidators, METH_O, "\n"
		"SBMLDocument_getApplicableValidators(SBMLDocument self) -> unsigned char\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_getConversionValidators", _wrap_SBMLDocument_getConversionValidators, METH_O, "\n"
		"SBMLDocument_getConversionValidators(SBMLDocument self) -> unsigned char\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_setApplicableValidators", _wrap_SBMLDocument_setApplicableValidators, METH_VARARGS, "\n"
		"SBMLDocument_setApplicableValidators(SBMLDocument self, unsigned char appl)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_setConversionValidators", _wrap_SBMLDocument_setConversionValidators, METH_VARARGS, "\n"
		"SBMLDocument_setConversionValidators(SBMLDocument self, unsigned char appl)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_getNumValidators", _wrap_SBMLDocument_getNumValidators, METH_O, "\n"
		"SBMLDocument_getNumValidators(SBMLDocument self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_clearValidators", _wrap_SBMLDocument_clearValidators, METH_O, "\n"
		"SBMLDocument_clearValidators(SBMLDocument self) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_addValidator", _wrap_SBMLDocument_addValidator, METH_VARARGS, "\n"
		"SBMLDocument_addValidator(SBMLDocument self, SBMLValidator validator) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_getValidator", _wrap_SBMLDocument_getValidator, METH_VARARGS, "\n"
		"SBMLDocument_getValidator(SBMLDocument self, unsigned int index) -> SBMLValidator\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_addUnknownPackageRequired", _wrap_SBMLDocument_addUnknownPackageRequired, METH_VARARGS, "\n"
		"SBMLDocument_addUnknownPackageRequired(SBMLDocument self, string pkgURI, string prefix, bool flag) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_hasUnknownPackage", _wrap_SBMLDocument_hasUnknownPackage, METH_VARARGS, "\n"
		"SBMLDocument_hasUnknownPackage(SBMLDocument self, string pkgURI) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_getNumUnknownPackages", _wrap_SBMLDocument_getNumUnknownPackages, METH_O, "\n"
		"SBMLDocument_getNumUnknownPackages(SBMLDocument self) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_getUnknownPackageURI", _wrap_SBMLDocument_getUnknownPackageURI, METH_VARARGS, "\n"
		"SBMLDocument_getUnknownPackageURI(SBMLDocument self, int index) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_getUnknownPackagePrefix", _wrap_SBMLDocument_getUnknownPackagePrefix, METH_VARARGS, "\n"
		"SBMLDocument_getUnknownPackagePrefix(SBMLDocument self, int index) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocument_swigregister", SBMLDocument_swigregister, METH_O, NULL},
	 { "SBMLDocument_swiginit", SBMLDocument_swiginit, METH_VARARGS, NULL},
	 { "delete_FunctionDefinition", _wrap_delete_FunctionDefinition, METH_O, "delete_FunctionDefinition(FunctionDefinition self)"},
	 { "new_FunctionDefinition", _wrap_new_FunctionDefinition, METH_VARARGS, "\n"
		"FunctionDefinition(unsigned int level, unsigned int version)\n"
		"FunctionDefinition(SBMLNamespaces sbmlns)\n"
		"new_FunctionDefinition(FunctionDefinition orig) -> FunctionDefinition\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    FunctionDefinition(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new FunctionDefinition using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    FunctionDefinition(long level, long version)\n"
		"\n"
		"Creates a new FunctionDefinition using the given SBML 'level' and\n"
		"'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"FunctionDefinition.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this FunctionDefinition.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    FunctionDefinition(FunctionDefinition orig)\n"
		"\n"
		"Copy constructor; creates a copy of this FunctionDefinition.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "FunctionDefinition_clone", _wrap_FunctionDefinition_clone, METH_O, "\n"
		"FunctionDefinition_clone(FunctionDefinition self) -> FunctionDefinition\n"
		"\n"
		"Creates and returns a deep copy of this FunctionDefinition object.\n"
		"\n"
		"Returns the (deep) copy of this FunctionDefinition object.\n"
		"\n"
		""},
	 { "FunctionDefinition_getId", _wrap_FunctionDefinition_getId, METH_O, "\n"
		"FunctionDefinition_getId(FunctionDefinition self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this FunctionDefinition.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() function instead.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this FunctionDefinition.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "FunctionDefinition_getName", _wrap_FunctionDefinition_getName, METH_O, "\n"
		"FunctionDefinition_getName(FunctionDefinition self) -> string\n"
		"\n"
		"Returns the value of the 'name' attribute of this FunctionDefinition\n"
		"object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns the name of this SBML object, or the empty string if not set\n"
		"or unsettable.\n"
		"\n"
		"See also getIdAttribute(), isSetName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "FunctionDefinition_getMath", _wrap_FunctionDefinition_getMath, METH_O, "\n"
		"FunctionDefinition_getMath(FunctionDefinition self) -> ASTNode\n"
		"\n"
		"Get the mathematical formula of this FunctionDefinition.\n"
		"\n"
		"Returns an ASTNode, the value of the 'math' subelement of this\n"
		"FunctionDefinition, or 'None' if the math is not set.\n"
		"\n"
		""},
	 { "FunctionDefinition_isSetId", _wrap_FunctionDefinition_isSetId, METH_O, "\n"
		"FunctionDefinition_isSetId(FunctionDefinition self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this FunctionDefinition's 'id' attribute\n"
		"is set.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is recommended that callers use\n"
		"isSetIdAttribute() instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),\n"
		"isSetIdAttribute().\n"
		"\n"
		""},
	 { "FunctionDefinition_isSetName", _wrap_FunctionDefinition_isSetName, METH_O, "\n"
		"FunctionDefinition_isSetName(FunctionDefinition self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this FunctionDefinition's 'name'\n"
		"attribute is set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns 'True' if the 'name' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "FunctionDefinition_isSetMath", _wrap_FunctionDefinition_isSetMath, METH_O, "\n"
		"FunctionDefinition_isSetMath(FunctionDefinition self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this FunctionDefinition's 'math'\n"
		"subelement contains a value.\n"
		"\n"
		"Returns 'True' if the 'math' for this FunctionDefinition is set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "FunctionDefinition_setId", _wrap_FunctionDefinition_setId, METH_VARARGS, "\n"
		"FunctionDefinition_setId(FunctionDefinition self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this FunctionDefinition.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "FunctionDefinition_setName", _wrap_FunctionDefinition_setName, METH_VARARGS, "\n"
		"FunctionDefinition_setName(FunctionDefinition self, string name) -> int\n"
		"\n"
		"Sets the value of the 'name' attribute of this FunctionDefinition.\n"
		"\n"
		"The string in 'name' is copied.\n"
		"\n"
		"Parameter 'name' is the new name for the SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "FunctionDefinition_setMath", _wrap_FunctionDefinition_setMath, METH_VARARGS, "\n"
		"FunctionDefinition_setMath(FunctionDefinition self, ASTNode math) -> int\n"
		"\n"
		"Sets the 'math' subelement of this FunctionDefinition to the Abstract\n"
		"Syntax Tree given in 'math'.\n"
		"\n"
		"Parameter 'math' is an AST containing the mathematical expression to\n"
		"be used as the formula for this FunctionDefinition.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "FunctionDefinition_unsetName", _wrap_FunctionDefinition_unsetName, METH_O, "\n"
		"FunctionDefinition_unsetName(FunctionDefinition self) -> int\n"
		"\n"
		"Unsets the value of the 'name' attribute of this FunctionDefinition.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getName(), setName(), isSetName().\n"
		"\n"
		""},
	 { "FunctionDefinition_getArgument", _wrap_FunctionDefinition_getArgument, METH_VARARGS, "\n"
		"FunctionDefinition_getArgument(FunctionDefinition self, unsigned int n) -> ASTNode\n"
		"FunctionDefinition_getArgument(FunctionDefinition self, string name) -> ASTNode\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getArgument(long n)\n"
		"\n"
		"Get the nth argument to this function.\n"
		"\n"
		"Callers should first find out the number of arguments to the function\n"
		"by calling getNumArguments().\n"
		"\n"
		"Parameter 'n' is an integer index for the argument sought.\n"
		"\n"
		"Returns the nth argument (bound variable) passed to this\n"
		"FunctionDefinition. If the index 'n' is invalid, 'None' is returned.\n"
		"\n"
		"See also getNumArguments().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getArgument(string name)\n"
		"\n"
		"Get the argument named 'name' to this FunctionDefinition.\n"
		"\n"
		"Parameter 'name' is the exact name (case-sensitive) of the sought-\n"
		"after argument.\n"
		"\n"
		"Returns the argument (bound variable) having the given name, or 'None'\n"
		"if no such argument exists.\n"
		"\n"
		""},
	 { "FunctionDefinition_getBody", _wrap_FunctionDefinition_getBody, METH_VARARGS, "\n"
		"FunctionDefinition_getBody(FunctionDefinition self) -> ASTNode\n"
		"FunctionDefinition_getBody(FunctionDefinition self) -> ASTNode\n"
		"\n"
		"Get the mathematical expression that is the body of this\n"
		"FunctionDefinition object.\n"
		"\n"
		"Returns the body of this FunctionDefinition as an Abstract Syntax\n"
		"Tree, or 'None' if no body is defined.\n"
		"\n"
		""},
	 { "FunctionDefinition_isSetBody", _wrap_FunctionDefinition_isSetBody, METH_O, "\n"
		"FunctionDefinition_isSetBody(FunctionDefinition self) -> bool\n"
		"\n"
		"Predicate returning 'True' if the body of this FunctionDefinition has\n"
		"set.\n"
		"\n"
		"Returns 'True' if the body of this FunctionDefinition is  set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "FunctionDefinition_getNumArguments", _wrap_FunctionDefinition_getNumArguments, METH_O, "\n"
		"FunctionDefinition_getNumArguments(FunctionDefinition self) -> unsigned int\n"
		"\n"
		"Get the number of arguments (bound variables) taken by this\n"
		"FunctionDefinition.\n"
		"\n"
		"Returns the number of arguments (bound variables) that must be passed\n"
		"to this FunctionDefinition.\n"
		"\n"
		""},
	 { "FunctionDefinition_getTypeCode", _wrap_FunctionDefinition_getTypeCode, METH_O, "\n"
		"FunctionDefinition_getTypeCode(FunctionDefinition self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_FUNCTION_DEFINITION\n"
		"(default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "FunctionDefinition_getElementName", _wrap_FunctionDefinition_getElementName, METH_O, "\n"
		"FunctionDefinition_getElementName(FunctionDefinition self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for\n"
		"FunctionDefinition, is always ''functionDefinition'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''functionDefinition'.'\n"
		"\n"
		""},
	 { "FunctionDefinition_hasRequiredAttributes", _wrap_FunctionDefinition_hasRequiredAttributes, METH_O, "\n"
		"FunctionDefinition_hasRequiredAttributes(FunctionDefinition self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"FunctionDefinition object have been set.\n"
		"\n"
		"The required attributes for a FunctionDefinition object are:\n"
		"\n"
		"* 'id'\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "FunctionDefinition_hasRequiredElements", _wrap_FunctionDefinition_hasRequiredElements, METH_O, "\n"
		"FunctionDefinition_hasRequiredElements(FunctionDefinition self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this\n"
		"FunctionDefinition object have been set.\n"
		"\n"
		"Note: The required elements for a FunctionDefinition object are:\n"
		"\n"
		"* 'math' inSBML Level 2 and Level 3 Version 1.   (In SBML Level 3\n"
		"Version 2+, it is no longer required.)\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "FunctionDefinition_renameUnitSIdRefs", _wrap_FunctionDefinition_renameUnitSIdRefs, METH_VARARGS, "\n"
		"FunctionDefinition_renameUnitSIdRefs(FunctionDefinition self, string oldid, string newid)\n"
		"\n"
		"Renames all the 'UnitSIdRef' attributes on this element.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the unit identifiers to the value of 'oldid'.  If any matches are\n"
		"found, the matching identifiers are replaced with 'newid'.  The method\n"
		"does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "FunctionDefinition_swigregister", FunctionDefinition_swigregister, METH_O, NULL},
	 { "FunctionDefinition_swiginit", FunctionDefinition_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfFunctionDefinitions", _wrap_new_ListOfFunctionDefinitions, METH_VARARGS, "\n"
		"ListOfFunctionDefinitions(unsigned int level, unsigned int version)\n"
		"new_ListOfFunctionDefinitions(SBMLNamespaces sbmlns) -> ListOfFunctionDefinitions\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfFunctionDefinitions(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfFunctionDefinitions object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfFunctionDefinitions object\n"
		"to be created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfFunctionDefinitions(long level, long version)\n"
		"\n"
		"Creates a new ListOfFunctionDefinitions object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfFunctionDefinitions_clone", _wrap_ListOfFunctionDefinitions_clone, METH_O, "\n"
		"ListOfFunctionDefinitions_clone(ListOfFunctionDefinitions self) -> ListOfFunctionDefinitions\n"
		"\n"
		"Creates and returns a deep copy of this ListOfFunctionDefinitions\n"
		"object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfFunctionDefinitions object.\n"
		"\n"
		""},
	 { "ListOfFunctionDefinitions_getItemTypeCode", _wrap_ListOfFunctionDefinitions_getItemTypeCode, METH_O, "\n"
		"ListOfFunctionDefinitions_getItemTypeCode(ListOfFunctionDefinitions self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., FunctionDefinition objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for the objects contained in this ListOf:\n"
		"SBML_FUNCTION_DEFINITION (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfFunctionDefinitions_getElementName", _wrap_ListOfFunctionDefinitions_getElementName, METH_O, "\n"
		"ListOfFunctionDefinitions_getElementName(ListOfFunctionDefinitions self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfFunctionDefinitions, the XML element name is\n"
		"''listOfFunctionDefinitions'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfFunctionDefinitions'.'\n"
		"\n"
		""},
	 { "ListOfFunctionDefinitions_get", _wrap_ListOfFunctionDefinitions_get, METH_VARARGS, "\n"
		"ListOfFunctionDefinitions_get(ListOfFunctionDefinitions self, unsigned int n) -> FunctionDefinition\n"
		"ListOfFunctionDefinitions_get(ListOfFunctionDefinitions self, unsigned int n) -> FunctionDefinition\n"
		"ListOfFunctionDefinitions_get(ListOfFunctionDefinitions self, string sid) -> FunctionDefinition\n"
		"ListOfFunctionDefinitions_get(ListOfFunctionDefinitions self, string sid) -> FunctionDefinition\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Get a FunctionDefinition from the ListOfFunctionDefinitions.\n"
		"\n"
		"Parameter 'n' is the index number of the FunctionDefinition to get.\n"
		"\n"
		"Returns the nth FunctionDefinition in this ListOfFunctionDefinitions.\n"
		"If the index 'n' is invalid, 'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Get a FunctionDefinition from the ListOfFunctionDefinitions based on\n"
		"its identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier  of the\n"
		"FunctionDefinition to get.\n"
		"\n"
		"Returns FunctionDefinition in this ListOfFunctionDefinitions with the\n"
		"given 'sid' or 'None' if no such FunctionDefinition exists.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfFunctionDefinitions_remove", _wrap_ListOfFunctionDefinitions_remove, METH_VARARGS, "\n"
		"ListOfFunctionDefinitions_remove(ListOfFunctionDefinitions self, unsigned int n) -> FunctionDefinition\n"
		"ListOfFunctionDefinitions_remove(ListOfFunctionDefinitions self, string sid) -> FunctionDefinition\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfFunctionDefinitions items and\n"
		"returns a pointer to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes item in this ListOfFunctionDefinitions items with the given\n"
		"identifier.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"If none of the items in this list have the identifier 'sid', then\n"
		"'None' is returned.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  As mentioned above, the caller owns the\n"
		"returned item.\n"
		"\n"
		""},
	 { "delete_ListOfFunctionDefinitions", _wrap_delete_ListOfFunctionDefinitions, METH_O, "delete_ListOfFunctionDefinitions(ListOfFunctionDefinitions self)"},
	 { "ListOfFunctionDefinitions_swigregister", ListOfFunctionDefinitions_swigregister, METH_O, NULL},
	 { "ListOfFunctionDefinitions_swiginit", ListOfFunctionDefinitions_swiginit, METH_VARARGS, NULL},
	 { "UnitKind_equals", _wrap_UnitKind_equals, METH_VARARGS, "\n"
		"UnitKind_equals(UnitKind_t uk1, UnitKind_t uk2) -> int\n"
		"\n"
		"Tests for logical equality between two given UNIT_KIND_ code values.\n"
		"\n"
		"This function behaves exactly like C's == operator, except for the\n"
		"following two cases:\n"
		"\n"
		"* UNIT_KIND_LITER == UNIT_KIND_LITRE\n"
		"\n"
		"* UNIT_KIND_METER == UNIT_KIND_METRE In the two cases above, C\n"
		"equality comparison would yield '0' (false) (because each of the above\n"
		"is a distinct enumeration value), but this function returns 'True.'\n"
		"\n"
		"Parameter 'uk1' is a UNIT_KIND_ value. Parameter 'uk2' is a second\n"
		"UNIT_KIND_ value to compare to 'uk1'.\n"
		"\n"
		"Returns '1' (true) if 'uk1' is logically equivalent to 'uk2', '0'\n"
		"(false) otherwise.\n"
		"\n"
		"Note: For more information about the libSBML unit codes, please refer\n"
		"to the class documentation for Unit.\n"
		"\n"
		""},
	 { "UnitKind_forName", _wrap_UnitKind_forName, METH_O, "\n"
		"UnitKind_forName(char const * name) -> UnitKind_t\n"
		"\n"
		"Converts a text string naming a kind of unit to its corresponding\n"
		"libSBML UNIT_KIND_ constant/enumeration value.\n"
		"\n"
		"Parameter 'name' is a string, the name of a predefined base unit in\n"
		"SBML.\n"
		"\n"
		"Returns a value the set of UNIT_KIND_ codes defined in class libsbml,\n"
		"corresponding to the string 'name' (determined in a case-insensitive\n"
		"manner).\n"
		"\n"
		"Note: For more information about the libSBML unit codes, please refer\n"
		"to the class documentation for Unit.\n"
		"\n"
		""},
	 { "UnitKind_toString", _wrap_UnitKind_toString, METH_O, "\n"
		"UnitKind_toString(UnitKind_t uk) -> char const *\n"
		"\n"
		"Converts a unit code to a text string equivalent.\n"
		"\n"
		"Parameter 'uk' is a value from the set of UNIT_KIND_ codes defined in\n"
		"the class libsbml\n"
		"\n"
		"Returns the name corresponding to the given unit code.\n"
		"\n"
		"Note: For more information about the libSBML unit codes, please refer\n"
		"to the class documentation for Unit.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The string returned is a static data value.  The caller does not own\n"
		"the returned string and is therefore not allowed to modify it.\n"
		"\n"
		""},
	 { "UnitKind_isValidUnitKindString", _wrap_UnitKind_isValidUnitKindString, METH_VARARGS, "\n"
		"UnitKind_isValidUnitKindString(char const * str, unsigned int level, unsigned int version) -> int\n"
		"\n"
		"Predicate for testing whether a given string corresponds to a\n"
		"predefined libSBML unit code.\n"
		"\n"
		"Parameter 'str' is a text string naming a base unit defined by SBML.\n"
		"Parameter 'level' is the Level of SBML. Parameter 'version' is the\n"
		"Version within the Level of SBML.\n"
		"\n"
		"Returns 1 (true) if string is the name of a valid UNIT_KIND_ value,\n"
		"'0' (false) otherwise.\n"
		"\n"
		"Note: For more information about the libSBML unit codes, please refer\n"
		"to the class documentation for Unit.\n"
		"\n"
		""},
	 { "delete_Unit", _wrap_delete_Unit, METH_O, "delete_Unit(Unit self)"},
	 { "new_Unit", _wrap_new_Unit, METH_VARARGS, "\n"
		"Unit(unsigned int level, unsigned int version)\n"
		"Unit(SBMLNamespaces sbmlns)\n"
		"new_Unit(Unit orig) -> Unit\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Unit(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new Unit using the given SBMLNamespaces object 'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Unit(long level, long version)\n"
		"\n"
		"Creates a new Unit using the given SBML 'level' and 'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"Unit.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this Unit.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Unit(Unit orig)\n"
		"\n"
		"Copy constructor; creates a copy of this Unit.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "Unit_clone", _wrap_Unit_clone, METH_O, "\n"
		"Unit_clone(Unit self) -> Unit\n"
		"\n"
		"Creates and returns a deep copy of this Unit object.\n"
		"\n"
		"Returns the (deep) copy of this Unit object.\n"
		"\n"
		""},
	 { "Unit_initDefaults", _wrap_Unit_initDefaults, METH_O, "\n"
		"Unit_initDefaults(Unit self)\n"
		"\n"
		"Initializes the fields of this Unit object to 'typical' default\n"
		"values.\n"
		"\n"
		"The SBML Unit component has slightly different aspects and default\n"
		"attribute values in different SBML Levels and Versions.  This method\n"
		"sets the values to certain common defaults, based mostly on what they\n"
		"are in SBML Level 2.  Specifically:\n"
		"\n"
		"* Sets attribute 'exponent' to '1'\n"
		"\n"
		"* Sets attribute 'scale' to '0'\n"
		"\n"
		"* Sets attribute 'multiplier' to '1.0' The 'kind' attribute is left\n"
		"unchanged.\n"
		"\n"
		""},
	 { "Unit_getKind", _wrap_Unit_getKind, METH_O, "\n"
		"Unit_getKind(Unit self) -> UnitKind_t\n"
		"\n"
		"Returns the 'kind' of Unit this is.\n"
		"\n"
		"Returns the value of the 'kind' attribute of this Unit as a value from\n"
		"the set of constants whose names begin with UNIT_KIND_ defined in the\n"
		"class libsbml.\n"
		"\n"
		""},
	 { "Unit_getExponent", _wrap_Unit_getExponent, METH_O, "\n"
		"Unit_getExponent(Unit self) -> int\n"
		"\n"
		"Returns the value of the 'exponent' attribute of this unit.\n"
		"\n"
		"Returns the 'exponent' value of this Unit, as an integer.\n"
		"\n"
		""},
	 { "Unit_getExponentAsDouble", _wrap_Unit_getExponentAsDouble, METH_O, "\n"
		"Unit_getExponentAsDouble(Unit self) -> double\n"
		"\n"
		"Returns the value of the 'exponent' attribute of this unit.\n"
		"\n"
		"Returns the 'exponent' value of this Unit, as a double.\n"
		"\n"
		""},
	 { "Unit_getScale", _wrap_Unit_getScale, METH_O, "\n"
		"Unit_getScale(Unit self) -> int\n"
		"\n"
		"Returns the value of the 'scale' attribute of this unit.\n"
		"\n"
		"Returns the 'scale' value of this Unit, as an integer.\n"
		"\n"
		""},
	 { "Unit_getMultiplier", _wrap_Unit_getMultiplier, METH_O, "\n"
		"Unit_getMultiplier(Unit self) -> double\n"
		"\n"
		"Returns the value of the 'multiplier' attribute of this Unit.\n"
		"\n"
		"Returns the 'multiplier' value of this Unit, as a double.\n"
		"\n"
		""},
	 { "Unit_getOffset", _wrap_Unit_getOffset, METH_O, "\n"
		"Unit_getOffset(Unit self) -> double\n"
		"\n"
		"Returns the value of the 'offset' attribute of this Unit.\n"
		"\n"
		"Returns the 'offset' value of this Unit, as a double.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The 'offset' attribute is only available in SBML Level 2 Version 1.\n"
		"This attribute is not present in SBML Level 2 Version 2 or above.\n"
		"When producing SBML models using these later specifications, modelers\n"
		"and software tools need to account for units with offsets explicitly.\n"
		"The SBML specification document offers a number of suggestions for how\n"
		"to achieve this.  LibSBML methods such as this one related to 'offset'\n"
		"are retained for compatibility with earlier versions of SBML Level 2,\n"
		"but their use is strongly discouraged.\n"
		"\n"
		""},
	 { "Unit_isAmpere", _wrap_Unit_isAmpere, METH_O, "\n"
		"Unit_isAmpere(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'ampere.'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'ampere,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isAvogadro", _wrap_Unit_isAvogadro, METH_O, "\n"
		"Unit_isAvogadro(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'avogadro.'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'avogadro,' 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: The unit 'avogadro' was introduced in SBML Level 3, and is only\n"
		"permitted for use in SBML Level 3 models.\n"
		"\n"
		""},
	 { "Unit_isBecquerel", _wrap_Unit_isBecquerel, METH_O, "\n"
		"Unit_isBecquerel(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'becquerel'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'becquerel,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isCandela", _wrap_Unit_isCandela, METH_O, "\n"
		"Unit_isCandela(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'candela'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'candela,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isCelsius", _wrap_Unit_isCelsius, METH_O, "\n"
		"Unit_isCelsius(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'Celsius'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'Celsius,' 'False'\n"
		"otherwise.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The predefined unit 'Celsius' was removed from the list of predefined\n"
		"units in SBML Level 2 Version 2 at the same time that the 'offset'\n"
		"attribute was removed from Unit definitions.  LibSBML methods such as\n"
		"this one related to 'Celsius' are retained in order to support SBML\n"
		"Level 2 Version 1, but their use is strongly discouraged.\n"
		"\n"
		""},
	 { "Unit_isCoulomb", _wrap_Unit_isCoulomb, METH_O, "\n"
		"Unit_isCoulomb(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'coulomb'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'coulomb,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isDimensionless", _wrap_Unit_isDimensionless, METH_O, "\n"
		"Unit_isDimensionless(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind\n"
		"'dimensionless.'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'dimensionless,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isFarad", _wrap_Unit_isFarad, METH_O, "\n"
		"Unit_isFarad(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'farad'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'farad,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isGram", _wrap_Unit_isGram, METH_O, "\n"
		"Unit_isGram(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'gram'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'gram,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isGray", _wrap_Unit_isGray, METH_O, "\n"
		"Unit_isGray(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'gray'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'gray,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isHenry", _wrap_Unit_isHenry, METH_O, "\n"
		"Unit_isHenry(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'henry'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'henry,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isHertz", _wrap_Unit_isHertz, METH_O, "\n"
		"Unit_isHertz(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'hertz'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'hertz,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isItem", _wrap_Unit_isItem, METH_O, "\n"
		"Unit_isItem(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'item'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'item,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isJoule", _wrap_Unit_isJoule, METH_O, "\n"
		"Unit_isJoule(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'joule'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'joule,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isKatal", _wrap_Unit_isKatal, METH_O, "\n"
		"Unit_isKatal(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'katal'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'katal,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isKelvin", _wrap_Unit_isKelvin, METH_O, "\n"
		"Unit_isKelvin(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'kelvin'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'kelvin,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isKilogram", _wrap_Unit_isKilogram, METH_O, "\n"
		"Unit_isKilogram(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'kilogram'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'kilogram,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isLitre", _wrap_Unit_isLitre, METH_O, "\n"
		"Unit_isLitre(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'litre'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'litre' or 'liter', 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isLumen", _wrap_Unit_isLumen, METH_O, "\n"
		"Unit_isLumen(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'lumen'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'lumen,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isLux", _wrap_Unit_isLux, METH_O, "\n"
		"Unit_isLux(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'lux'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'lux,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isMetre", _wrap_Unit_isMetre, METH_O, "\n"
		"Unit_isMetre(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'metre'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'metre' or 'meter', 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isMole", _wrap_Unit_isMole, METH_O, "\n"
		"Unit_isMole(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'mole'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'mole,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isNewton", _wrap_Unit_isNewton, METH_O, "\n"
		"Unit_isNewton(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'newton'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'newton,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isOhm", _wrap_Unit_isOhm, METH_O, "\n"
		"Unit_isOhm(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'ohm'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'ohm,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isPascal", _wrap_Unit_isPascal, METH_O, "\n"
		"Unit_isPascal(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'pascal'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'pascal,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isRadian", _wrap_Unit_isRadian, METH_O, "\n"
		"Unit_isRadian(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'radian'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'radian,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isSecond", _wrap_Unit_isSecond, METH_O, "\n"
		"Unit_isSecond(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'second'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'second,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isSiemens", _wrap_Unit_isSiemens, METH_O, "\n"
		"Unit_isSiemens(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'siemens'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'siemens,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isSievert", _wrap_Unit_isSievert, METH_O, "\n"
		"Unit_isSievert(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'sievert'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'sievert,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isSteradian", _wrap_Unit_isSteradian, METH_O, "\n"
		"Unit_isSteradian(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'steradian'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'steradian,' 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isTesla", _wrap_Unit_isTesla, METH_O, "\n"
		"Unit_isTesla(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'tesla'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'tesla,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isVolt", _wrap_Unit_isVolt, METH_O, "\n"
		"Unit_isVolt(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'volt'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'volt,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isWatt", _wrap_Unit_isWatt, METH_O, "\n"
		"Unit_isWatt(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'watt'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'watt,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isWeber", _wrap_Unit_isWeber, METH_O, "\n"
		"Unit_isWeber(Unit self) -> bool\n"
		"\n"
		"Predicate for testing whether this Unit is of the kind 'weber'\n"
		"\n"
		"Returns 'True' if the kind of this Unit is 'weber,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isSetKind", _wrap_Unit_isSetKind, METH_O, "\n"
		"Unit_isSetKind(Unit self) -> bool\n"
		"\n"
		"Predicate to test whether the 'kind' attribute of this Unit is set.\n"
		"\n"
		"Returns 'True' if the 'kind' attribute of this Unit is set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isSetExponent", _wrap_Unit_isSetExponent, METH_O, "\n"
		"Unit_isSetExponent(Unit self) -> bool\n"
		"\n"
		"Predicate to test whether the 'exponent' attribute of this Unit  is\n"
		"set.\n"
		"\n"
		"Returns 'True' if the 'exponent' attribute of this Unit is set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isSetScale", _wrap_Unit_isSetScale, METH_O, "\n"
		"Unit_isSetScale(Unit self) -> bool\n"
		"\n"
		"Predicate to test whether the 'scale' attribute of this Unit  is set.\n"
		"\n"
		"Returns 'True' if the 'scale' attribute of this Unit is set,  'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_isSetMultiplier", _wrap_Unit_isSetMultiplier, METH_O, "\n"
		"Unit_isSetMultiplier(Unit self) -> bool\n"
		"\n"
		"Predicate to test whether the 'multiplier' attribute of this Unit  is\n"
		"set.\n"
		"\n"
		"Returns 'True' if the 'multiplier' attribute of this Unit is set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "Unit_isSetOffset", _wrap_Unit_isSetOffset, METH_O, "\n"
		"Unit_isSetOffset(Unit self) -> bool\n"
		"\n"
		"Predicate to test whether the 'offset' attribute of this Unit  is set.\n"
		"\n"
		"Returns 'True' if the 'offset' attribute of this Unit is set,  'False'\n"
		"otherwise.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The 'offset' attribute is only available in SBML Level 2 Version 1.\n"
		"This attribute is not present in SBML Level 2 Version 2 or above.\n"
		"When producing SBML models using these later specifications, modelers\n"
		"and software tools need to account for units with offsets explicitly.\n"
		"The SBML specification document offers a number of suggestions for how\n"
		"to achieve this.  LibSBML methods such as this one related to 'offset'\n"
		"are retained for compatibility with earlier versions of SBML Level 2,\n"
		"but their use is strongly discouraged.\n"
		"\n"
		""},
	 { "Unit_setKind", _wrap_Unit_setKind, METH_VARARGS, "\n"
		"Unit_setKind(Unit self, UnitKind_t kind) -> int\n"
		"\n"
		"Sets the 'kind' attribute value of this Unit.\n"
		"\n"
		"Parameter 'kind' is a unit identifier chosen from the set of constants\n"
		"whose names begin with UNIT_KIND_ in libsbml.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Unit_setExponent", _wrap_Unit_setExponent, METH_VARARGS, "\n"
		"Unit_setExponent(Unit self, int value) -> int\n"
		"Unit_setExponent(Unit self, double value) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setExponent(int value)\n"
		"\n"
		"Sets the 'exponent' attribute value of this Unit.\n"
		"\n"
		"Parameter 'value' is the integer to which the attribute 'exponent'\n"
		"should be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setExponent(double value)\n"
		"\n"
		"Sets the 'exponent' attribute value of this Unit.\n"
		"\n"
		"Parameter 'value' is the double to which the attribute 'exponent'\n"
		"should be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "Unit_setScale", _wrap_Unit_setScale, METH_VARARGS, "\n"
		"Unit_setScale(Unit self, int value) -> int\n"
		"\n"
		"Sets the 'scale' attribute value of this Unit.\n"
		"\n"
		"Parameter 'value' is the integer to which the attribute 'scale' should\n"
		"be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "Unit_setMultiplier", _wrap_Unit_setMultiplier, METH_VARARGS, "\n"
		"Unit_setMultiplier(Unit self, double value) -> int\n"
		"\n"
		"Sets the 'multipler' attribute value of this Unit.\n"
		"\n"
		"Parameter 'value' is the floating-point value to which the attribute\n"
		"'multiplier' should be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		""},
	 { "Unit_setOffset", _wrap_Unit_setOffset, METH_VARARGS, "\n"
		"Unit_setOffset(Unit self, double value) -> int\n"
		"\n"
		"Sets the 'offset' attribute value of this Unit.\n"
		"\n"
		"Parameter 'value' is the floating point value to which the attribute\n"
		"'offset' should set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The 'offset' attribute is only available in SBML Level 2 Version 1.\n"
		"This attribute is not present in SBML Level 2 Version 2 or above.\n"
		"When producing SBML models using these later specifications, modelers\n"
		"and software tools need to account for units with offsets explicitly.\n"
		"The SBML specification document offers a number of suggestions for how\n"
		"to achieve this.  LibSBML methods such as this one related to 'offset'\n"
		"are retained for compatibility with earlier versions of SBML Level 2,\n"
		"but their use is strongly discouraged.\n"
		"\n"
		""},
	 { "Unit_unsetKind", _wrap_Unit_unsetKind, METH_O, "\n"
		"Unit_unsetKind(Unit self) -> int\n"
		"\n"
		"Unsets the 'kind' attribute value of this Unit.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Unit_unsetExponent", _wrap_Unit_unsetExponent, METH_O, "\n"
		"Unit_unsetExponent(Unit self) -> int\n"
		"\n"
		"Unsets the 'exponent' attribute value of this Unit.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Unit_unsetScale", _wrap_Unit_unsetScale, METH_O, "\n"
		"Unit_unsetScale(Unit self) -> int\n"
		"\n"
		"Unsets the 'scale' attribute value of this Unit.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "Unit_unsetMultiplier", _wrap_Unit_unsetMultiplier, METH_O, "\n"
		"Unit_unsetMultiplier(Unit self) -> int\n"
		"\n"
		"Unsets the 'multipler' attribute value of this Unit.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		""},
	 { "Unit_unsetOffset", _wrap_Unit_unsetOffset, METH_O, "\n"
		"Unit_unsetOffset(Unit self) -> int\n"
		"\n"
		"Unsets the 'offset' attribute value of this Unit.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The 'offset' attribute is only available in SBML Level 2 Version 1.\n"
		"This attribute is not present in SBML Level 2 Version 2 or above.\n"
		"When producing SBML models using these later specifications, modelers\n"
		"and software tools need to account for units with offsets explicitly.\n"
		"The SBML specification document offers a number of suggestions for how\n"
		"to achieve this.  LibSBML methods such as this one related to 'offset'\n"
		"are retained for compatibility with earlier versions of SBML Level 2,\n"
		"but their use is strongly discouraged.\n"
		"\n"
		""},
	 { "Unit_getTypeCode", _wrap_Unit_getTypeCode, METH_O, "\n"
		"Unit_getTypeCode(Unit self) -> int\n"
		"\n"
		"Returns the libSBML type code of this object instance.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_UNIT (default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getPackageName(), getElementName().\n"
		"\n"
		""},
	 { "Unit_getElementName", _wrap_Unit_getElementName, METH_O, "\n"
		"Unit_getElementName(Unit self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for Unit, is always\n"
		"''unit'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''unit'.'\n"
		"\n"
		""},
	 { "Unit_isBuiltIn", _wrap_Unit_isBuiltIn, METH_VARARGS, "\n"
		"Unit_isBuiltIn(string name, unsigned int level) -> bool\n"
		"\n"
		"Predicate to test whether a given string is the name of a built-in\n"
		"SBML unit, depending on the SBML level, since new predefined units\n"
		"were added between level 2 versions 1 and 2, and then all predefined\n"
		"units were removed again in SBML Level 3.\n"
		"\n"
		"Parameter 'name' is a string to be tested against the built-in unit\n"
		"names. Parameter 'level' is the level of SBML one is checking.\n"
		"\n"
		"Returns 'True' if 'name' is one of ''substance',' ''volume',' or\n"
		"''time'' and the 'level' is '1;' or if 'name' is one of ''substance','\n"
		"''volume',' ''area',' ''length',' or ''time'' and the 'level' is '2;'\n"
		"'False' otherwise (including all values when 'level' is '3).'\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "Unit_isUnitKind", _wrap_Unit_isUnitKind, METH_VARARGS, "\n"
		"Unit_isUnitKind(string name, unsigned int level, unsigned int version) -> bool\n"
		"\n"
		"Predicate to test whether a given string is the name of a valid base\n"
		"unit in SBML (such as ''gram'' or ''mole').'\n"
		"\n"
		"This method exists because prior to SBML Level 2 Version 3, an\n"
		"enumeration called 'UnitKind' was defined by SBML.  This enumeration\n"
		"was removed in SBML Level 2 Version 3 and its values were folded into\n"
		"the space of values of a type called 'UnitSId.'  This method therefore\n"
		"has less significance in SBML Level 2 Version 3 and Level 2 Version 4,\n"
		"but remains for backward compatibility and support for reading models\n"
		"in older Versions of Level 2.\n"
		"\n"
		"Parameter 'name' is a string to be tested.\n"
		"\n"
		"Parameter 'level' is a long integer representing the SBML\n"
		"specification Level.\n"
		"\n"
		"Parameter 'version' is a long integer representing the SBML\n"
		"specification Version.\n"
		"\n"
		"Returns 'True' if name is a valid SBML UnitKind, 'False' otherwise.\n"
		"\n"
		"Note: The allowed unit names differ between SBML Levels 1 and 2 and\n"
		"again slightly between Level 2 Versions 1 and 2.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "Unit_areIdentical", _wrap_Unit_areIdentical, METH_VARARGS, "\n"
		"Unit_areIdentical(Unit unit1, Unit unit2) -> bool\n"
		"\n"
		"Predicate returning 'True' if two Unit objects are identical.\n"
		"\n"
		"Two Unit objects are considered to be identical if they match in all\n"
		"attributes.  (Contrast this to the method areEquivalent(), which\n"
		"compares Unit objects only with respect to certain attributes.)\n"
		"\n"
		"Parameter 'unit1' is the first Unit object to compare. Parameter\n"
		"'unit2' is the second Unit object to compare.\n"
		"\n"
		"Returns 'True' if all the attributes of unit1 are identical to the\n"
		"attributes of unit2, 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also Unit.areEquivalent() .\n"
		"\n"
		""},
	 { "Unit_areEquivalent", _wrap_Unit_areEquivalent, METH_VARARGS, "\n"
		"Unit_areEquivalent(Unit unit1, Unit unit2) -> bool\n"
		"\n"
		"Predicate returning 'True' if  Unit objects are equivalent.\n"
		"\n"
		"Two Unit objects are considered to be equivalent either if (1) both\n"
		"have a 'kind' attribute value of 'dimensionless,' or (2) their 'kind',\n"
		"'exponent' and (for SBML Level 2 Version 1) 'offset' attribute values\n"
		"are equal. (Contrast this to the method areIdentical(), which compares\n"
		"Unit objects with respect to all attributes, not just the 'kind' and\n"
		"'exponent'.)\n"
		"\n"
		"Parameter 'unit1' is the first Unit object to compare. Parameter\n"
		"'unit2' is the second Unit object to compare.\n"
		"\n"
		"Returns 'True' if the 'kind' and 'exponent' attributes of unit1 are\n"
		"identical to the kind and exponent attributes of unit2, or if the kind\n"
		"attributes of both are 'dimensionless;' 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also Unit.areIdentical() .\n"
		"\n"
		""},
	 { "Unit_removeScale", _wrap_Unit_removeScale, METH_O, "\n"
		"Unit_removeScale(Unit unit) -> int\n"
		"\n"
		"Manipulates the attributes of the Unit to express the unit with the\n"
		"value of the scale attribute reduced to zero.\n"
		"\n"
		"For example, 1 millimetre can be expressed as a Unit with kind=\n"
		"''metre'' multiplier=''1'' scale=''-3'' exponent=''1'.' It can also be\n"
		"expressed as a Unit with kind=''metre'' multiplier='0.001' scale=''0''\n"
		"exponent=''1'.'\n"
		"\n"
		"Parameter 'unit' is the Unit object to manipulate.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also Unit.convertToSI() , Unit.merge() .\n"
		"\n"
		""},
	 { "Unit_merge", _wrap_Unit_merge, METH_VARARGS, "\n"
		"Unit_merge(Unit unit1, Unit unit2)\n"
		"\n"
		"Merges two Unit objects with the same 'kind' attribute value into a\n"
		"single Unit.\n"
		"\n"
		"For example, the following,\n"
		"\n"
		"   <unit kind='metre' exponent='2'/>\n"
		"   <unit kind='metre' exponent='1'/>\n"
		"\n"
		"would be merged to become\n"
		"\n"
		"   <unit kind='metre' exponent='3'/>\n"
		"\n"
		"Parameter 'unit1' is the first Unit object; the result of the\n"
		"operation is left as a new version of this unit, modified in-place.\n"
		"Not modified if the two units have different kinds.\n"
		"\n"
		"Parameter 'unit2' is the second Unit object to merge with the first.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also Unit.convertToSI() , Unit.removeScale() .\n"
		"\n"
		""},
	 { "Unit_convertToSI", _wrap_Unit_convertToSI, METH_O, "\n"
		"Unit_convertToSI(Unit unit) -> UnitDefinition\n"
		"\n"
		"Returns a UnitDefinition object containing the given 'unit' converted\n"
		"to the appropriate SI unit.\n"
		"\n"
		"This method exists because some units can be expressed in terms of\n"
		"others when the same physical dimension is involved.  For example, one\n"
		"hertz is identical to 1 sec^-1, one litre is equivalent to 1 cubic\n"
		"decametre, and so on.\n"
		"\n"
		"Parameter 'unit' is the Unit object to convert to SI.\n"
		"\n"
		"Returns a UnitDefinition object containing the SI unit.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also Unit.merge() .\n"
		"\n"
		""},
	 { "Unit_hasRequiredAttributes", _wrap_Unit_hasRequiredAttributes, METH_O, "\n"
		"Unit_hasRequiredAttributes(Unit self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"Unit object have been set.\n"
		"\n"
		"The required attributes for a Unit object are:\n"
		"\n"
		"* 'kind'\n"
		"\n"
		"* 'exponent' (required in SBML Level 3; optional in Level 2)\n"
		"\n"
		"* 'multiplier' (required in SBML Level 3; optional in Level 2)\n"
		"\n"
		"* 'scale' (required in SBML Level 3; optional in Level 2)\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Unit_setExponentUnitChecking", _wrap_Unit_setExponentUnitChecking, METH_VARARGS, "\n"
		"Unit_setExponentUnitChecking(Unit self, double value)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Unit_getExponentUnitChecking", _wrap_Unit_getExponentUnitChecking, METH_VARARGS, "\n"
		"Unit_getExponentUnitChecking(Unit self) -> double\n"
		"Unit_getExponentUnitChecking(Unit self) -> double\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Unit_isUnitChecking", _wrap_Unit_isUnitChecking, METH_VARARGS, "\n"
		"Unit_isUnitChecking(Unit self) -> bool\n"
		"Unit_isUnitChecking(Unit self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Unit_swigregister", Unit_swigregister, METH_O, NULL},
	 { "Unit_swiginit", Unit_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfUnits", _wrap_new_ListOfUnits, METH_VARARGS, "\n"
		"ListOfUnits(unsigned int level, unsigned int version)\n"
		"new_ListOfUnits(SBMLNamespaces sbmlns) -> ListOfUnits\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfUnits(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfUnits object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfUnits object to be created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfUnits(long level, long version)\n"
		"\n"
		"Creates a new ListOfUnits object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfUnits_clone", _wrap_ListOfUnits_clone, METH_O, "\n"
		"ListOfUnits_clone(ListOfUnits self) -> ListOfUnits\n"
		"\n"
		"Creates and returns a deep copy of this ListOfUnits object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfUnits object.\n"
		"\n"
		""},
	 { "ListOfUnits_getItemTypeCode", _wrap_ListOfUnits_getItemTypeCode, METH_O, "\n"
		"ListOfUnits_getItemTypeCode(ListOfUnits self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., Unit objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for objects contained in this list:\n"
		"SBML_UNIT (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfUnits_getElementName", _wrap_ListOfUnits_getElementName, METH_O, "\n"
		"ListOfUnits_getElementName(ListOfUnits self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfUnits, the XML element name is ''listOfUnits'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfUnits'.'\n"
		"\n"
		""},
	 { "ListOfUnits_get", _wrap_ListOfUnits_get, METH_VARARGS, "\n"
		"ListOfUnits_get(ListOfUnits self, unsigned int n) -> Unit\n"
		"ListOfUnits_get(ListOfUnits self, unsigned int n) -> Unit\n"
		"\n"
		"Get a Unit from the ListOfUnits.\n"
		"\n"
		"Parameter 'n' is the index number of the Unit to get.\n"
		"\n"
		"Returns the nth Unit in this ListOfUnits. If the index 'n' is invalid,\n"
		"'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		""},
	 { "ListOfUnits_remove", _wrap_ListOfUnits_remove, METH_VARARGS, "\n"
		"ListOfUnits_remove(ListOfUnits self, unsigned int n) -> Unit\n"
		"\n"
		"Removes the nth item from this ListOfUnits items and returns a pointer\n"
		"to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		""},
	 { "delete_ListOfUnits", _wrap_delete_ListOfUnits, METH_O, "delete_ListOfUnits(ListOfUnits self)"},
	 { "ListOfUnits_swigregister", ListOfUnits_swigregister, METH_O, NULL},
	 { "ListOfUnits_swiginit", ListOfUnits_swiginit, METH_VARARGS, NULL},
	 { "delete_UnitDefinition", _wrap_delete_UnitDefinition, METH_O, "delete_UnitDefinition(UnitDefinition self)"},
	 { "new_UnitDefinition", _wrap_new_UnitDefinition, METH_VARARGS, "\n"
		"UnitDefinition(unsigned int level, unsigned int version)\n"
		"UnitDefinition(SBMLNamespaces sbmlns)\n"
		"new_UnitDefinition(UnitDefinition orig) -> UnitDefinition\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    UnitDefinition(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new UnitDefinition using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    UnitDefinition(long level, long version)\n"
		"\n"
		"Creates a new UnitDefinition using the given SBML 'level' and\n"
		"'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"UnitDefinition.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this UnitDefinition.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    UnitDefinition(UnitDefinition orig)\n"
		"\n"
		"Copy constructor; creates a copy of this UnitDefinition.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "UnitDefinition_clone", _wrap_UnitDefinition_clone, METH_O, "\n"
		"UnitDefinition_clone(UnitDefinition self) -> UnitDefinition\n"
		"\n"
		"Creates and returns a deep copy of this UnitDefinition object.\n"
		"\n"
		"Returns the (deep) copy of this UnitDefinition object.\n"
		"\n"
		""},
	 { "UnitDefinition_getElementBySId", _wrap_UnitDefinition_getElementBySId, METH_VARARGS, "\n"
		"UnitDefinition_getElementBySId(UnitDefinition self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given 'id' in the\n"
		"model-wide SId namespace, or 'None' if no such object is found.\n"
		"\n"
		"Parameter 'id' is string representing the id of the object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'id'.\n"
		"\n"
		""},
	 { "UnitDefinition_getElementByMetaId", _wrap_UnitDefinition_getElementByMetaId, METH_VARARGS, "\n"
		"UnitDefinition_getElementByMetaId(UnitDefinition self, string metaid) -> SBase\n"
		"\n"
		"Returns the first child element it can find with the given 'metaid',\n"
		"or 'None' if no such object is found.\n"
		"\n"
		"Parameter 'metaid' is string representing the metaid of the object to\n"
		"find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'metaid'.\n"
		"\n"
		""},
	 { "UnitDefinition_getId", _wrap_UnitDefinition_getId, METH_O, "\n"
		"UnitDefinition_getId(UnitDefinition self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this UnitDefinition.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() function instead.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this UnitDefinition.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "UnitDefinition_getName", _wrap_UnitDefinition_getName, METH_O, "\n"
		"UnitDefinition_getName(UnitDefinition self) -> string\n"
		"\n"
		"Returns the value of the 'name' attribute of this UnitDefinition\n"
		"object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns the name of this SBML object, or the empty string if not set\n"
		"or unsettable.\n"
		"\n"
		"See also getIdAttribute(), isSetName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "UnitDefinition_isSetId", _wrap_UnitDefinition_isSetId, METH_O, "\n"
		"UnitDefinition_isSetId(UnitDefinition self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this UnitDefinition's 'id' attribute is\n"
		"set.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is recommended that callers use\n"
		"isSetIdAttribute() instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),\n"
		"isSetIdAttribute().\n"
		"\n"
		""},
	 { "UnitDefinition_isSetName", _wrap_UnitDefinition_isSetName, METH_O, "\n"
		"UnitDefinition_isSetName(UnitDefinition self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this UnitDefinition's 'name' attribute\n"
		"is set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns 'True' if the 'name' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "UnitDefinition_setId", _wrap_UnitDefinition_setId, METH_VARARGS, "\n"
		"UnitDefinition_setId(UnitDefinition self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this UnitDefinition.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "UnitDefinition_setName", _wrap_UnitDefinition_setName, METH_VARARGS, "\n"
		"UnitDefinition_setName(UnitDefinition self, string name) -> int\n"
		"\n"
		"Sets the value of the 'name' attribute of this UnitDefinition.\n"
		"\n"
		"The string in 'name' is copied.\n"
		"\n"
		"Parameter 'name' is the new name for the SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "UnitDefinition_unsetName", _wrap_UnitDefinition_unsetName, METH_O, "\n"
		"UnitDefinition_unsetName(UnitDefinition self) -> int\n"
		"\n"
		"Unsets the value of the 'name' attribute of this UnitDefinition.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getName(), setName(), isSetName().\n"
		"\n"
		""},
	 { "UnitDefinition_isVariantOfArea", _wrap_UnitDefinition_isVariantOfArea, METH_VARARGS, "\n"
		"UnitDefinition_isVariantOfArea(UnitDefinition self, bool relaxed=False) -> bool\n"
		"\n"
		"Convenience function for testing if a given unit definition is a\n"
		"variant of the predefined unit identifier ''area'.'\n"
		"\n"
		"Returns 'True' if this UnitDefinition is a variant of the predefined\n"
		"unit 'area,' meaning square metres with only arbitrary variations in\n"
		"scale or multiplier values; 'False' otherwise.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "UnitDefinition_isVariantOfLength", _wrap_UnitDefinition_isVariantOfLength, METH_VARARGS, "\n"
		"UnitDefinition_isVariantOfLength(UnitDefinition self, bool relaxed=False) -> bool\n"
		"\n"
		"Convenience function for testing if a given unit definition is a\n"
		"variant of the predefined unit identifier ''length'.'\n"
		"\n"
		"Returns 'True' if this UnitDefinition is a variant of the predefined\n"
		"unit 'length,' meaning metres with only arbitrary variations in scale\n"
		"or multiplier values; 'False' otherwise.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "UnitDefinition_isVariantOfSubstance", _wrap_UnitDefinition_isVariantOfSubstance, METH_VARARGS, "\n"
		"UnitDefinition_isVariantOfSubstance(UnitDefinition self, bool relaxed=False) -> bool\n"
		"\n"
		"Convenience function for testing if a given unit definition is a\n"
		"variant of the predefined unit identifier ''substance'.'\n"
		"\n"
		"Returns 'True' if this UnitDefinition is a variant of the predefined\n"
		"unit 'substance,' meaning moles or items (and grams or kilograms from\n"
		"SBML Level 2 Version 2 onwards) with only arbitrary variations in\n"
		"scale or multiplier values; 'False' otherwise.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "UnitDefinition_isVariantOfTime", _wrap_UnitDefinition_isVariantOfTime, METH_VARARGS, "\n"
		"UnitDefinition_isVariantOfTime(UnitDefinition self, bool relaxed=False) -> bool\n"
		"\n"
		"Convenience function for testing if a given unit definition is a\n"
		"variant of the predefined unit identifier ''time'.'\n"
		"\n"
		"Returns 'True' if this UnitDefinition is a variant of the predefined\n"
		"unit 'time,' meaning seconds with only arbitrary variations in scale\n"
		"or multiplier values; 'False' otherwise.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "UnitDefinition_isVariantOfVolume", _wrap_UnitDefinition_isVariantOfVolume, METH_VARARGS, "\n"
		"UnitDefinition_isVariantOfVolume(UnitDefinition self, bool relaxed=False) -> bool\n"
		"\n"
		"Convenience function for testing if a given unit definition is a\n"
		"variant of the predefined unit identifier ''volume'.'\n"
		"\n"
		"Returns 'True' if this UnitDefinition is a variant of the predefined\n"
		"unit 'volume,' meaning litre or cubic metre with only arbitrary\n"
		"variations in scale or multiplier values; 'False' otherwise.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "UnitDefinition_isVariantOfDimensionless", _wrap_UnitDefinition_isVariantOfDimensionless, METH_VARARGS, "\n"
		"UnitDefinition_isVariantOfDimensionless(UnitDefinition self, bool relaxed=False) -> bool\n"
		"\n"
		"Convenience function for testing if a given unit definition is a\n"
		"variant of the unit ''dimensionless'.'\n"
		"\n"
		"Returns 'True' if this UnitDefinition is a variant of 'dimensionless,'\n"
		"meaning dimensionless with only arbitrary variations in scale or\n"
		"multiplier values; 'False' otherwise.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "UnitDefinition_isVariantOfMass", _wrap_UnitDefinition_isVariantOfMass, METH_VARARGS, "\n"
		"UnitDefinition_isVariantOfMass(UnitDefinition self, bool relaxed=False) -> bool\n"
		"\n"
		"Convenience function for testing if a given unit definition is a\n"
		"variant of the predefined unit identifier ''mass'.'\n"
		"\n"
		"Returns 'True' if this UnitDefinition is a variant of mass units,\n"
		"meaning gram or kilogram with only arbitrary variations in scale or\n"
		"multiplier values; 'False' otherwise.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "UnitDefinition_isVariantOfSubstancePerTime", _wrap_UnitDefinition_isVariantOfSubstancePerTime, METH_VARARGS, "\n"
		"UnitDefinition_isVariantOfSubstancePerTime(UnitDefinition self, bool relaxed=False) -> bool\n"
		"\n"
		"Convenience function for testing if a given unit definition is a\n"
		"variant of the predefined unit ''substance'' divided by the predefined\n"
		"unit ''time'.'\n"
		"\n"
		"Returns 'True' if this UnitDefinition is a variant of the predefined\n"
		"unit 'substance' per predefined unit 'time,' meaning it contains two\n"
		"units one of which is a variant of substance and the other is a\n"
		"variant of time which an exponent of -1; 'False' otherwise.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "UnitDefinition_addUnit", _wrap_UnitDefinition_addUnit, METH_VARARGS, "\n"
		"UnitDefinition_addUnit(UnitDefinition self, Unit u) -> int\n"
		"\n"
		"Adds a copy of the given Unit to this UnitDefinition.\n"
		"\n"
		"Parameter 'u' is the Unit instance to add to this UnitDefinition.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createUnit().\n"
		"\n"
		""},
	 { "UnitDefinition_createUnit", _wrap_UnitDefinition_createUnit, METH_O, "\n"
		"UnitDefinition_createUnit(UnitDefinition self) -> Unit\n"
		"\n"
		"Creates a new and empty Unit, adds it to this UnitDefinition's list of\n"
		"units, and returns it.\n"
		"\n"
		"Returns a newly constructed (and empty) Unit instance.\n"
		"\n"
		"Note: It is worth emphasizing that the attribute 'kind' value of a\n"
		"Unit is a required attribute for a valid Unit definition.  The\n"
		"createUnit() method does not assign a valid kind to the constructed\n"
		"unit (instead, it sets the 'kind' to UNIT_KIND_INVALID). Callers are\n"
		"cautioned to set the newly-constructed Unit's kind using\n"
		"Unit.setKind() soon after calling this method.\n"
		"\n"
		"See also addUnit().\n"
		"\n"
		""},
	 { "UnitDefinition_getListOfUnits", _wrap_UnitDefinition_getListOfUnits, METH_VARARGS, "\n"
		"UnitDefinition_getListOfUnits(UnitDefinition self) -> ListOfUnits\n"
		"UnitDefinition_getListOfUnits(UnitDefinition self) -> ListOfUnits\n"
		"\n"
		"Returns the list of Units for this UnitDefinition instance. Returns\n"
		"the ListOfUnits value for this UnitDefinition.\n"
		"\n"
		""},
	 { "UnitDefinition_getUnit", _wrap_UnitDefinition_getUnit, METH_VARARGS, "\n"
		"UnitDefinition_getUnit(UnitDefinition self, unsigned int n) -> Unit\n"
		"UnitDefinition_getUnit(UnitDefinition self, unsigned int n) -> Unit\n"
		"\n"
		"Returns a specific Unit instance belonging to this UnitDefinition.\n"
		"\n"
		"Parameter 'n' is an integer, the index of the Unit to be returned.\n"
		"\n"
		"Returns the nth Unit of this UnitDefinition. If the index 'n' is\n"
		"invalid, 'None' is returned.\n"
		"\n"
		"See also getNumUnits().\n"
		"\n"
		""},
	 { "UnitDefinition_getNumUnits", _wrap_UnitDefinition_getNumUnits, METH_O, "\n"
		"UnitDefinition_getNumUnits(UnitDefinition self) -> unsigned int\n"
		"\n"
		"Returns the number of Unit objects contained within this\n"
		"UnitDefinition.\n"
		"\n"
		"Returns an integer representing the number of Units in this\n"
		"UnitDefinition.\n"
		"\n"
		""},
	 { "UnitDefinition_removeUnit", _wrap_UnitDefinition_removeUnit, METH_VARARGS, "\n"
		"UnitDefinition_removeUnit(UnitDefinition self, unsigned int n) -> Unit\n"
		"\n"
		"Removes the nth Unit object from this UnitDefinition object and\n"
		"returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the Unit object to remove.\n"
		"\n"
		"Returns the Unit object removed, or 'None' if the given index  is out\n"
		"of range.\n"
		"\n"
		""},
	 { "UnitDefinition_connectToChild", _wrap_UnitDefinition_connectToChild, METH_O, "UnitDefinition_connectToChild(UnitDefinition self)"},
	 { "UnitDefinition_enablePackageInternal", _wrap_UnitDefinition_enablePackageInternal, METH_VARARGS, "\n"
		"UnitDefinition_enablePackageInternal(UnitDefinition self, string pkgURI, string pkgPrefix, bool flag)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "UnitDefinition_updateSBMLNamespace", _wrap_UnitDefinition_updateSBMLNamespace, METH_VARARGS, "\n"
		"UnitDefinition_updateSBMLNamespace(UnitDefinition self, string package, unsigned int level, unsigned int version)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "UnitDefinition_getTypeCode", _wrap_UnitDefinition_getTypeCode, METH_O, "\n"
		"UnitDefinition_getTypeCode(UnitDefinition self) -> int\n"
		"\n"
		"Returns the libSBML type code for this object instance.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_UNIT_DEFINITION\n"
		"(default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getPackageName(), getElementName().\n"
		"\n"
		""},
	 { "UnitDefinition_getElementName", _wrap_UnitDefinition_getElementName, METH_O, "\n"
		"UnitDefinition_getElementName(UnitDefinition self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for UnitDefinition,\n"
		"is always ''unitDefinition'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''unitDefinition'.'\n"
		"\n"
		""},
	 { "UnitDefinition_simplify", _wrap_UnitDefinition_simplify, METH_O, "\n"
		"UnitDefinition_simplify(UnitDefinition ud)\n"
		"\n"
		"Simplifies the UnitDefinition such that any given kind of Unit object\n"
		"occurs only once in the ListOfUnits.\n"
		"\n"
		"For example, the following definition,\n"
		"\n"
		"   <unitDefinition>\n"
		"    <listOfUnits>\n"
		"      <unit kind='metre' exponent='1'/>\n"
		"      <unit kind='metre' exponent='2'/>\n"
		"    </listOfUnits>\n"
		"   <unitDefinition>\n"
		"\n"
		"will be simplified to\n"
		"\n"
		"   <unitDefinition>\n"
		"     <listOfUnits>\n"
		"       <unit kind='metre' exponent='3'/>\n"
		"     </listOfUnits>\n"
		"   <unitDefinition>\n"
		"\n"
		"Parameter 'ud' is the UnitDefinition object to be simplified.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "UnitDefinition_reorder", _wrap_UnitDefinition_reorder, METH_O, "\n"
		"UnitDefinition_reorder(UnitDefinition ud)\n"
		"\n"
		"Alphabetically orders the Unit objects within the ListOfUnits of a\n"
		"UnitDefinition.\n"
		"\n"
		"Parameter 'ud' is the UnitDefinition object whose units are to be\n"
		"reordered.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "UnitDefinition_convertToSI", _wrap_UnitDefinition_convertToSI, METH_O, "\n"
		"UnitDefinition_convertToSI(UnitDefinition ud) -> UnitDefinition\n"
		"\n"
		"Convert a given UnitDefinition into a new UnitDefinition object that\n"
		"uses SI units.\n"
		"\n"
		"Parameter 'ud' is the UnitDefinition object to convert to SI.\n"
		"\n"
		"Returns a new UnitDefinition object representing the results of the\n"
		"conversion.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "UnitDefinition_areIdentical", _wrap_UnitDefinition_areIdentical, METH_VARARGS, "\n"
		"UnitDefinition_areIdentical(UnitDefinition ud1, UnitDefinition ud2) -> bool\n"
		"\n"
		"Predicate returning 'True' if two UnitDefinition objects are\n"
		"identical.\n"
		"\n"
		"For the purposes of performing this comparison, two UnitDefinition\n"
		"objects are considered identical when they contain identical lists of\n"
		"Unit objects.  Pairs of Unit objects in the lists are in turn\n"
		"considered identical if they satisfy the predicate\n"
		"Unit.areIdentical(). The predicate compares every attribute of the\n"
		"Unit objects.\n"
		"\n"
		"Parameter 'ud1' is the first UnitDefinition object to compare.\n"
		"Parameter 'ud2' is the second UnitDefinition object to compare.\n"
		"\n"
		"Returns 'True' if all the Unit objects in 'ud1' are identical to the\n"
		"Unit objects of 'ud2', 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also UnitDefinition.areEquivalent(), Unit.areIdentical().\n"
		"\n"
		""},
	 { "UnitDefinition_areEquivalent", _wrap_UnitDefinition_areEquivalent, METH_VARARGS, "\n"
		"UnitDefinition_areEquivalent(UnitDefinition ud1, UnitDefinition ud2) -> bool\n"
		"\n"
		"Predicate returning 'True' if two UnitDefinition objects are\n"
		"equivalent.\n"
		"\n"
		"For the purposes of performing this comparison, two UnitDefinition\n"
		"objects are considered equivalent when they contain equivalent list of\n"
		"Unit objects.  Unit objects are in turn considered equivalent if they\n"
		"satisfy the predicate Unit.areEquivalent(). The predicate tests a\n"
		"subset of the objects's attributes.\n"
		"\n"
		"Parameter 'ud1' is the first UnitDefinition object to compare.\n"
		"\n"
		"Parameter 'ud2' is the second UnitDefinition object to compare.\n"
		"\n"
		"Returns 'True' if all the Unit objects in 'ud1' are equivalent to the\n"
		"Unit objects in 'ud2', 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also UnitDefinition.areIdentical(), Unit.areEquivalent().\n"
		"\n"
		""},
	 { "UnitDefinition_combine", _wrap_UnitDefinition_combine, METH_VARARGS, "\n"
		"UnitDefinition_combine(UnitDefinition ud1, UnitDefinition ud2) -> UnitDefinition\n"
		"\n"
		"Combines two UnitDefinition objects into a single UnitDefinition.\n"
		"\n"
		"This takes UnitDefinition objects 'ud1' and 'ud2', and creates a\n"
		"UnitDefinition object that expresses the product of the units of 'ud1'\n"
		"and 'ud2'.\n"
		"\n"
		"Parameter 'ud1' is the first UnitDefinition object. Parameter 'ud2' is\n"
		"the second UnitDefinition object.\n"
		"\n"
		"Returns a UnitDefinition which represents the product of the  units of\n"
		"the two argument UnitDefinitions.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "UnitDefinition_divide", _wrap_UnitDefinition_divide, METH_VARARGS, "\n"
		"UnitDefinition_divide(UnitDefinition ud1, UnitDefinition ud2) -> UnitDefinition\n"
		"\n"
		"Combines two UnitDefinition objects into a single UnitDefinition as a\n"
		"division.\n"
		"\n"
		"This takes UnitDefinition objects 'ud1' and 'ud2', and creates a\n"
		"UnitDefinition object that expresses the division of the units of\n"
		"'ud1' and 'ud2'.\n"
		"\n"
		"Parameter 'ud1' is the first UnitDefinition object. Parameter 'ud2' is\n"
		"the second UnitDefinition object.\n"
		"\n"
		"Returns a UnitDefinition which represents the division of the  units\n"
		"of the two argument UnitDefinitions.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "UnitDefinition_printUnits", _wrap_UnitDefinition_printUnits, METH_VARARGS, "\n"
		"UnitDefinition_printUnits(UnitDefinition ud, bool compact=False) -> string\n"
		"\n"
		"Expresses the given definition in a plain-text form.\n"
		"\n"
		"For example, UnitDefinition.printUnits() applied to\n"
		"\n"
		"   <unitDefinition>\n"
		"    <listOfUnits>\n"
		"      <unit kind='metre' exponent='1'/>\n"
		"      <unit kind='second' exponent='-2'/>\n"
		"    </listOfUnits>\n"
		"   <unitDefinition>\n"
		"\n"
		"will return the string 'metre (exponent = 1, multiplier = 1, scale =\n"
		"0) second (exponent = -2, multiplier = 1, scale = 0)' or, if the\n"
		"optional parameter 'compact' is given the value 'True,' the string '(1\n"
		"metre)^1 (1 second)^-2'.  This method may be useful for printing unit\n"
		"information to human users, or in debugging software, or other\n"
		"situations.\n"
		"\n"
		"Parameter 'ud' is the UnitDefinition object. Parameter 'compact' is\n"
		"boolean indicating whether the compact form should be used (defaults\n"
		"to false).\n"
		"\n"
		"Returns a string expressing the unit definition defined by the given\n"
		"UnitDefinition object 'ud'.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "UnitDefinition_hasRequiredAttributes", _wrap_UnitDefinition_hasRequiredAttributes, METH_O, "\n"
		"UnitDefinition_hasRequiredAttributes(UnitDefinition self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"UnitDefinition object have been set.\n"
		"\n"
		"The required attributes for a UnitDefinition object are:\n"
		"\n"
		"* 'id'\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "UnitDefinition_hasRequiredElements", _wrap_UnitDefinition_hasRequiredElements, METH_O, "\n"
		"UnitDefinition_hasRequiredElements(UnitDefinition self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this\n"
		"UnitDefinition object have been set.\n"
		"\n"
		"Note: The required elements for a Constraint object are:\n"
		"\n"
		"* 'listOfUnits' (required in SBML Level 2 only, optional in Level\n"
		"3)\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "UnitDefinition_swigregister", UnitDefinition_swigregister, METH_O, NULL},
	 { "UnitDefinition_swiginit", UnitDefinition_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfUnitDefinitions", _wrap_new_ListOfUnitDefinitions, METH_VARARGS, "\n"
		"ListOfUnitDefinitions(unsigned int level, unsigned int version)\n"
		"new_ListOfUnitDefinitions(SBMLNamespaces sbmlns) -> ListOfUnitDefinitions\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfUnitDefinitions(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfUnitDefinitions object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfUnitDefinitions object to\n"
		"be created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfUnitDefinitions(long level, long version)\n"
		"\n"
		"Creates a new ListOfUnitDefinitions object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfUnitDefinitions_clone", _wrap_ListOfUnitDefinitions_clone, METH_O, "\n"
		"ListOfUnitDefinitions_clone(ListOfUnitDefinitions self) -> ListOfUnitDefinitions\n"
		"\n"
		"Creates and returns a deep copy of this ListOfUnitDefinitions object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfUnitDefinitions object.\n"
		"\n"
		""},
	 { "ListOfUnitDefinitions_getItemTypeCode", _wrap_ListOfUnitDefinitions_getItemTypeCode, METH_O, "\n"
		"ListOfUnitDefinitions_getItemTypeCode(ListOfUnitDefinitions self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., UnitDefinition objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for objects contained in this list:\n"
		"SBML_UNIT_DEFINITION (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfUnitDefinitions_getElementName", _wrap_ListOfUnitDefinitions_getElementName, METH_O, "\n"
		"ListOfUnitDefinitions_getElementName(ListOfUnitDefinitions self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfUnitDefinitions, the XML element name is\n"
		"''listOfUnitDefinitions'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfUnitDefinitions'.'\n"
		"\n"
		""},
	 { "ListOfUnitDefinitions_get", _wrap_ListOfUnitDefinitions_get, METH_VARARGS, "\n"
		"ListOfUnitDefinitions_get(ListOfUnitDefinitions self, unsigned int n) -> UnitDefinition\n"
		"ListOfUnitDefinitions_get(ListOfUnitDefinitions self, unsigned int n) -> UnitDefinition\n"
		"ListOfUnitDefinitions_get(ListOfUnitDefinitions self, string sid) -> UnitDefinition\n"
		"ListOfUnitDefinitions_get(ListOfUnitDefinitions self, string sid) -> UnitDefinition\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Get a UnitDefinition from the ListOfUnitDefinitions.\n"
		"\n"
		"Parameter 'n' is the index number of the UnitDefinition to get.\n"
		"\n"
		"Returns the nth UnitDefinition in this ListOfUnitDefinitions. If the\n"
		"index 'n' is invalid, 'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Get a UnitDefinition from the ListOfUnitDefinitions based on its\n"
		"identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier  of the\n"
		"UnitDefinition to get.\n"
		"\n"
		"Returns UnitDefinition in this ListOfUnitDefinitions with the given\n"
		"'sid' or 'None' if no such UnitDefinition exists.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfUnitDefinitions_getElementBySId", _wrap_ListOfUnitDefinitions_getElementBySId, METH_VARARGS, "\n"
		"ListOfUnitDefinitions_getElementBySId(ListOfUnitDefinitions self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given 'id' in the\n"
		"model-wide SId namespace, or 'None' if no such object is found.\n"
		"\n"
		"Note that UnitDefinitions themselves are in the UnitId namespace, not\n"
		"the SId namespace, so no UnitDefinition object will be returned from\n"
		"this function (and is the reason we override the base\n"
		"ListOf::getElementBySId function here).\n"
		"\n"
		"Parameter 'id' is string representing the id of the object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'id'.\n"
		"\n"
		""},
	 { "ListOfUnitDefinitions_remove", _wrap_ListOfUnitDefinitions_remove, METH_VARARGS, "\n"
		"ListOfUnitDefinitions_remove(ListOfUnitDefinitions self, unsigned int n) -> UnitDefinition\n"
		"ListOfUnitDefinitions_remove(ListOfUnitDefinitions self, string sid) -> UnitDefinition\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfUnitDefinitions items and returns\n"
		"a pointer to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes item in this ListOfUnitDefinitions items with the given\n"
		"identifier.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"If none of the items in this list have the identifier 'sid', then\n"
		"'None' is returned.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  As mentioned above, the caller owns the\n"
		"returned item.\n"
		"\n"
		""},
	 { "delete_ListOfUnitDefinitions", _wrap_delete_ListOfUnitDefinitions, METH_O, "delete_ListOfUnitDefinitions(ListOfUnitDefinitions self)"},
	 { "ListOfUnitDefinitions_swigregister", ListOfUnitDefinitions_swigregister, METH_O, NULL},
	 { "ListOfUnitDefinitions_swiginit", ListOfUnitDefinitions_swiginit, METH_VARARGS, NULL},
	 { "delete_CompartmentType", _wrap_delete_CompartmentType, METH_O, "delete_CompartmentType(CompartmentType self)"},
	 { "new_CompartmentType", _wrap_new_CompartmentType, METH_VARARGS, "\n"
		"CompartmentType(unsigned int level, unsigned int version)\n"
		"CompartmentType(SBMLNamespaces sbmlns)\n"
		"new_CompartmentType(CompartmentType orig) -> CompartmentType\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    CompartmentType(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new CompartmentType object using the given SBMLNamespaces\n"
		"object 'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"It is worth emphasizing that although this constructor does not take\n"
		"an identifier argument, in SBML Level 2 and beyond, the 'id'\n"
		"(identifier) attribute of a CompartmentType object is required to have\n"
		"a value.  Thus, callers are cautioned to assign a value after calling\n"
		"this constructor.  Setting the identifier can be accomplished using\n"
		"the method setId().\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    CompartmentType(long level, long version)\n"
		"\n"
		"Creates a new CompartmentType object using the given SBML 'level' and\n"
		"'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"CompartmentType.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this CompartmentType.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    CompartmentType(CompartmentType orig)\n"
		"\n"
		"Copy constructor; creates a copy of this CompartmentType object.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "CompartmentType_clone", _wrap_CompartmentType_clone, METH_O, "\n"
		"CompartmentType_clone(CompartmentType self) -> CompartmentType\n"
		"\n"
		"Creates and returns a deep copy of this CompartmentType object.\n"
		"\n"
		"Returns the (deep) copy of this CompartmentType object.\n"
		"\n"
		""},
	 { "CompartmentType_getId", _wrap_CompartmentType_getId, METH_O, "\n"
		"CompartmentType_getId(CompartmentType self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this CompartmentType.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() function instead.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this CompartmentType.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "CompartmentType_getName", _wrap_CompartmentType_getName, METH_O, "\n"
		"CompartmentType_getName(CompartmentType self) -> string\n"
		"\n"
		"Returns the value of the 'name' attribute of this CompartmentType\n"
		"object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns the name of this SBML object, or the empty string if not set\n"
		"or unsettable.\n"
		"\n"
		"See also getIdAttribute(), isSetName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "CompartmentType_isSetId", _wrap_CompartmentType_isSetId, METH_O, "\n"
		"CompartmentType_isSetId(CompartmentType self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this CompartmentType object's 'id'\n"
		"attribute is set.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is recommended that callers use\n"
		"isSetIdAttribute() instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),\n"
		"isSetIdAttribute().\n"
		"\n"
		""},
	 { "CompartmentType_isSetName", _wrap_CompartmentType_isSetName, METH_O, "\n"
		"CompartmentType_isSetName(CompartmentType self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this CompartmentType object's 'name'\n"
		"attribute is set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns 'True' if the 'name' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "CompartmentType_setId", _wrap_CompartmentType_setId, METH_VARARGS, "\n"
		"CompartmentType_setId(CompartmentType self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this CompartmentType.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "CompartmentType_setName", _wrap_CompartmentType_setName, METH_VARARGS, "\n"
		"CompartmentType_setName(CompartmentType self, string name) -> int\n"
		"\n"
		"Sets the value of the 'name' attribute of this CompartmentType.\n"
		"\n"
		"The string in 'name' is copied.\n"
		"\n"
		"Parameter 'name' is the new name for the SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "CompartmentType_unsetName", _wrap_CompartmentType_unsetName, METH_O, "\n"
		"CompartmentType_unsetName(CompartmentType self) -> int\n"
		"\n"
		"Unsets the value of the 'name' attribute of this CompartmentType\n"
		"object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getName(), setName(), isSetName().\n"
		"\n"
		""},
	 { "CompartmentType_getTypeCode", _wrap_CompartmentType_getTypeCode, METH_O, "\n"
		"CompartmentType_getTypeCode(CompartmentType self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_COMPARTMENT_TYPE\n"
		"(default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "CompartmentType_getElementName", _wrap_CompartmentType_getElementName, METH_O, "\n"
		"CompartmentType_getElementName(CompartmentType self) -> string\n"
		"\n"
		"Returns the XML element name of this object\n"
		"\n"
		"For CompartmentType, the element name is always ''compartmentType'.'\n"
		"\n"
		"Returns the name of this element.\n"
		"\n"
		"See also getTypeCode(), getPackageName().\n"
		"\n"
		""},
	 { "CompartmentType_hasRequiredAttributes", _wrap_CompartmentType_hasRequiredAttributes, METH_O, "\n"
		"CompartmentType_hasRequiredAttributes(CompartmentType self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"CompartmentType object have been set.\n"
		"\n"
		"The required attributes for a CompartmentType object are:\n"
		"\n"
		"* 'id'\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "CompartmentType_swigregister", CompartmentType_swigregister, METH_O, NULL},
	 { "CompartmentType_swiginit", CompartmentType_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfCompartmentTypes", _wrap_new_ListOfCompartmentTypes, METH_VARARGS, "\n"
		"ListOfCompartmentTypes(unsigned int level, unsigned int version)\n"
		"new_ListOfCompartmentTypes(SBMLNamespaces sbmlns) -> ListOfCompartmentTypes\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfCompartmentTypes(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfCompartmentTypes object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfCompartmentTypes object to\n"
		"be created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfCompartmentTypes(long level, long version)\n"
		"\n"
		"Creates a new ListOfCompartmentTypes object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfCompartmentTypes_clone", _wrap_ListOfCompartmentTypes_clone, METH_O, "\n"
		"ListOfCompartmentTypes_clone(ListOfCompartmentTypes self) -> ListOfCompartmentTypes\n"
		"\n"
		"Creates and returns a deep copy of this ListOfCompartmentTypes object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfCompartmentTypes object.\n"
		"\n"
		""},
	 { "ListOfCompartmentTypes_getItemTypeCode", _wrap_ListOfCompartmentTypes_getItemTypeCode, METH_O, "\n"
		"ListOfCompartmentTypes_getItemTypeCode(ListOfCompartmentTypes self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., CompartmentType objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for the objects contained in this ListOf\n"
		"instance: SBML_COMPARTMENT_TYPE (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfCompartmentTypes_getElementName", _wrap_ListOfCompartmentTypes_getElementName, METH_O, "\n"
		"ListOfCompartmentTypes_getElementName(ListOfCompartmentTypes self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfCompartmentTypes, the XML element name is\n"
		"''listOfCompartmentTypes'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfCompartmentTypes'.'\n"
		"\n"
		""},
	 { "ListOfCompartmentTypes_get", _wrap_ListOfCompartmentTypes_get, METH_VARARGS, "\n"
		"ListOfCompartmentTypes_get(ListOfCompartmentTypes self, unsigned int n) -> CompartmentType\n"
		"ListOfCompartmentTypes_get(ListOfCompartmentTypes self, unsigned int n) -> CompartmentType\n"
		"ListOfCompartmentTypes_get(ListOfCompartmentTypes self, string sid) -> CompartmentType\n"
		"ListOfCompartmentTypes_get(ListOfCompartmentTypes self, string sid) -> CompartmentType\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Get a CompartmentType object from the ListOfCompartmentTypes.\n"
		"\n"
		"Parameter 'n' is the index number of the CompartmentType object to\n"
		"get.\n"
		"\n"
		"Returns the nth CompartmentType object in this ListOfCompartmentTypes.\n"
		"If the index 'n' is invalid, 'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Get a CompartmentType object from the ListOfCompartmentTypes based on\n"
		"its identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier of the\n"
		"CompartmentType object to get.\n"
		"\n"
		"Returns CompartmentType object in this ListOfCompartmentTypes with the\n"
		"given 'sid' or 'None' if no such CompartmentType object exists.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfCompartmentTypes_remove", _wrap_ListOfCompartmentTypes_remove, METH_VARARGS, "\n"
		"ListOfCompartmentTypes_remove(ListOfCompartmentTypes self, unsigned int n) -> CompartmentType\n"
		"ListOfCompartmentTypes_remove(ListOfCompartmentTypes self, string sid) -> CompartmentType\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfCompartmentTypes items and\n"
		"returns a pointer to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes item in this ListOfCompartmentTypes items with the given\n"
		"identifier.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"If none of the items in this list have the identifier 'sid', then\n"
		"'None' is returned.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  As mentioned above, the caller owns the\n"
		"returned item.\n"
		"\n"
		""},
	 { "delete_ListOfCompartmentTypes", _wrap_delete_ListOfCompartmentTypes, METH_O, "delete_ListOfCompartmentTypes(ListOfCompartmentTypes self)"},
	 { "ListOfCompartmentTypes_swigregister", ListOfCompartmentTypes_swigregister, METH_O, NULL},
	 { "ListOfCompartmentTypes_swiginit", ListOfCompartmentTypes_swiginit, METH_VARARGS, NULL},
	 { "delete_SpeciesType", _wrap_delete_SpeciesType, METH_O, "delete_SpeciesType(SpeciesType self)"},
	 { "new_SpeciesType", _wrap_new_SpeciesType, METH_VARARGS, "\n"
		"SpeciesType(unsigned int level, unsigned int version)\n"
		"SpeciesType(SBMLNamespaces sbmlns)\n"
		"new_SpeciesType(SpeciesType orig) -> SpeciesType\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SpeciesType(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new SpeciesType using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"It is worth emphasizing that although this constructor does not take\n"
		"an identifier argument, in SBML Level 2 and beyond, the 'id'\n"
		"(identifier) attribute of a SpeciesType object is required to have a\n"
		"value. Thus, callers are cautioned to assign a value after calling\n"
		"this constructor.  Setting the identifier can be accomplished using\n"
		"the method SBase.setId().\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SpeciesType(long level, long version)\n"
		"\n"
		"Creates a new SpeciesType using the given SBML 'level' and 'version'\n"
		"values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"SpeciesType.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this SpeciesType.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SpeciesType(SpeciesType orig)\n"
		"\n"
		"Copy constructor; creates a copy of this SpeciesType.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "SpeciesType_clone", _wrap_SpeciesType_clone, METH_O, "\n"
		"SpeciesType_clone(SpeciesType self) -> SpeciesType\n"
		"\n"
		"Creates and returns a deep copy of this SpeciesType object.\n"
		"\n"
		"Returns the (deep) copy of this SpeciesType object.\n"
		"\n"
		""},
	 { "SpeciesType_getId", _wrap_SpeciesType_getId, METH_O, "\n"
		"SpeciesType_getId(SpeciesType self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this SpeciesType.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() function instead.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this SpeciesType.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "SpeciesType_getName", _wrap_SpeciesType_getName, METH_O, "\n"
		"SpeciesType_getName(SpeciesType self) -> string\n"
		"\n"
		"Returns the value of the 'name' attribute of this SpeciesType object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns the name of this SBML object, or the empty string if not set\n"
		"or unsettable.\n"
		"\n"
		"See also getIdAttribute(), isSetName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "SpeciesType_isSetId", _wrap_SpeciesType_isSetId, METH_O, "\n"
		"SpeciesType_isSetId(SpeciesType self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this SpeciesType's 'id' attribute is\n"
		"set.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is recommended that callers use\n"
		"isSetIdAttribute() instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),\n"
		"isSetIdAttribute().\n"
		"\n"
		""},
	 { "SpeciesType_isSetName", _wrap_SpeciesType_isSetName, METH_O, "\n"
		"SpeciesType_isSetName(SpeciesType self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this SpeciesType's 'name' attribute is\n"
		"set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns 'True' if the 'name' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "SpeciesType_setId", _wrap_SpeciesType_setId, METH_VARARGS, "\n"
		"SpeciesType_setId(SpeciesType self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this SpeciesType.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "SpeciesType_setName", _wrap_SpeciesType_setName, METH_VARARGS, "\n"
		"SpeciesType_setName(SpeciesType self, string name) -> int\n"
		"\n"
		"Sets the value of the 'name' attribute of this SpeciesType.\n"
		"\n"
		"The string in 'name' is copied.\n"
		"\n"
		"Parameter 'name' is the new name for the SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "SpeciesType_unsetName", _wrap_SpeciesType_unsetName, METH_O, "\n"
		"SpeciesType_unsetName(SpeciesType self) -> int\n"
		"\n"
		"Unsets the value of the 'name' attribute of this SpeciesType.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getName(), setName(), isSetName().\n"
		"\n"
		""},
	 { "SpeciesType_getTypeCode", _wrap_SpeciesType_getTypeCode, METH_O, "\n"
		"SpeciesType_getTypeCode(SpeciesType self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_SPECIES_TYPE\n"
		"(default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "SpeciesType_getElementName", _wrap_SpeciesType_getElementName, METH_O, "\n"
		"SpeciesType_getElementName(SpeciesType self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for SpeciesType, is\n"
		"always ''compartmentType'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''compartmentType'.'\n"
		"\n"
		""},
	 { "SpeciesType_hasRequiredAttributes", _wrap_SpeciesType_hasRequiredAttributes, METH_O, "\n"
		"SpeciesType_hasRequiredAttributes(SpeciesType self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"SpeciesType object have been set.\n"
		"\n"
		"The required attributes for a SpeciesType object are:\n"
		"\n"
		"* 'id'\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SpeciesType_swigregister", SpeciesType_swigregister, METH_O, NULL},
	 { "SpeciesType_swiginit", SpeciesType_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfSpeciesTypes", _wrap_new_ListOfSpeciesTypes, METH_VARARGS, "\n"
		"ListOfSpeciesTypes(unsigned int level, unsigned int version)\n"
		"new_ListOfSpeciesTypes(SBMLNamespaces sbmlns) -> ListOfSpeciesTypes\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfSpeciesTypes(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfSpeciesTypes object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfSpeciesTypes object to be\n"
		"created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfSpeciesTypes(long level, long version)\n"
		"\n"
		"Creates a new ListOfSpeciesTypes object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfSpeciesTypes_clone", _wrap_ListOfSpeciesTypes_clone, METH_O, "\n"
		"ListOfSpeciesTypes_clone(ListOfSpeciesTypes self) -> ListOfSpeciesTypes\n"
		"\n"
		"Creates and returns a deep copy of this ListOfSpeciesTypes object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfSpeciesTypes object.\n"
		"\n"
		""},
	 { "ListOfSpeciesTypes_getItemTypeCode", _wrap_ListOfSpeciesTypes_getItemTypeCode, METH_O, "\n"
		"ListOfSpeciesTypes_getItemTypeCode(ListOfSpeciesTypes self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., SpeciesType objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for objects contained in this list:\n"
		"SBML_SPECIES_TYPE (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfSpeciesTypes_getElementName", _wrap_ListOfSpeciesTypes_getElementName, METH_O, "\n"
		"ListOfSpeciesTypes_getElementName(ListOfSpeciesTypes self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfSpeciesTypes, the XML element name is\n"
		"''listOfSpeciesTypes'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfSpeciesTypes'.'\n"
		"\n"
		""},
	 { "ListOfSpeciesTypes_get", _wrap_ListOfSpeciesTypes_get, METH_VARARGS, "\n"
		"ListOfSpeciesTypes_get(ListOfSpeciesTypes self, unsigned int n) -> SpeciesType\n"
		"ListOfSpeciesTypes_get(ListOfSpeciesTypes self, unsigned int n) -> SpeciesType\n"
		"ListOfSpeciesTypes_get(ListOfSpeciesTypes self, string sid) -> SpeciesType\n"
		"ListOfSpeciesTypes_get(ListOfSpeciesTypes self, string sid) -> SpeciesType\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Get a SpeciesType from the ListOfSpeciesTypes.\n"
		"\n"
		"Parameter 'n' is the index number of the SpeciesType to get.\n"
		"\n"
		"Returns the nth SpeciesType in this ListOfSpeciesTypes. If the index\n"
		"'n' is invalid, 'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Get a SpeciesType from the ListOfSpeciesTypes based on its identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier  of the\n"
		"SpeciesType to get.\n"
		"\n"
		"Returns SpeciesType in this ListOfSpeciesTypes with the given 'sid' or\n"
		"'None' if no such SpeciesType exists.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfSpeciesTypes_remove", _wrap_ListOfSpeciesTypes_remove, METH_VARARGS, "\n"
		"ListOfSpeciesTypes_remove(ListOfSpeciesTypes self, unsigned int n) -> SpeciesType\n"
		"ListOfSpeciesTypes_remove(ListOfSpeciesTypes self, string sid) -> SpeciesType\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfSpeciesTypes items and returns a\n"
		"pointer to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes item in this ListOfSpeciesTypes items with the given\n"
		"identifier.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"If none of the items in this list have the identifier 'sid', then\n"
		"'None' is returned.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  As mentioned above, the caller owns the\n"
		"returned item.\n"
		"\n"
		""},
	 { "delete_ListOfSpeciesTypes", _wrap_delete_ListOfSpeciesTypes, METH_O, "delete_ListOfSpeciesTypes(ListOfSpeciesTypes self)"},
	 { "ListOfSpeciesTypes_swigregister", ListOfSpeciesTypes_swigregister, METH_O, NULL},
	 { "ListOfSpeciesTypes_swiginit", ListOfSpeciesTypes_swiginit, METH_VARARGS, NULL},
	 { "delete_Compartment", _wrap_delete_Compartment, METH_O, "delete_Compartment(Compartment self)"},
	 { "new_Compartment", _wrap_new_Compartment, METH_VARARGS, "\n"
		"Compartment(unsigned int level, unsigned int version)\n"
		"Compartment(SBMLNamespaces sbmlns)\n"
		"new_Compartment(Compartment orig) -> Compartment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Compartment(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new Compartment object using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"It is worth emphasizing that although this constructor does not take\n"
		"an identifier argument, in SBML Level 2 and beyond, the 'id'\n"
		"(identifier) attribute of a Compartment object is required to have a\n"
		"value.  Thus, callers are cautioned to assign a value after calling\n"
		"this constructor.  Setting the identifier can be accomplished using\n"
		"the method setId().\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Compartment(long level, long version)\n"
		"\n"
		"Creates a new Compartment object using the given SBML 'level' and\n"
		"'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"Compartment.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this Compartment.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Compartment(Compartment orig)\n"
		"\n"
		"Copy constructor.\n"
		"\n"
		"This creates a copy of a Compartment object.\n"
		"\n"
		"Parameter 'orig' is the Compartment instance to copy.\n"
		"\n"
		""},
	 { "Compartment_clone", _wrap_Compartment_clone, METH_O, "\n"
		"Compartment_clone(Compartment self) -> Compartment\n"
		"\n"
		"Creates and returns a deep copy of this Compartment object.\n"
		"\n"
		"Returns the (deep) copy of this Compartment object.\n"
		"\n"
		""},
	 { "Compartment_initDefaults", _wrap_Compartment_initDefaults, METH_O, "\n"
		"Compartment_initDefaults(Compartment self)\n"
		"\n"
		"Initializes the fields of this Compartment object to 'typical' default\n"
		"values.\n"
		"\n"
		"The SBML Compartment component has slightly different aspects and\n"
		"default attribute values in different SBML Levels and Versions. This\n"
		"method sets the values to certain common defaults, based mostly on\n"
		"what they are in SBML Level 2.  Specifically:\n"
		"\n"
		"* Sets attribute 'spatialDimensions' to '3'\n"
		"\n"
		"* Sets attribute 'constant' to 'True'\n"
		"\n"
		"* (Applies to Level 1 models only) Sets attribute 'volume' to '1.0'\n"
		"\n"
		"* (Applies to Level 3 models only) Sets attribute 'units' to\n"
		"'litre'\n"
		"\n"
		""},
	 { "Compartment_getId", _wrap_Compartment_getId, METH_O, "\n"
		"Compartment_getId(Compartment self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this Compartment.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() function instead.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this Compartment.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Compartment_getName", _wrap_Compartment_getName, METH_O, "\n"
		"Compartment_getName(Compartment self) -> string\n"
		"\n"
		"Returns the value of the 'name' attribute of this Compartment object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns the name of this SBML object, or the empty string if not set\n"
		"or unsettable.\n"
		"\n"
		"See also getIdAttribute(), isSetName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "Compartment_getCompartmentType", _wrap_Compartment_getCompartmentType, METH_O, "\n"
		"Compartment_getCompartmentType(Compartment self) -> string\n"
		"\n"
		"Get the value of the 'compartmentType' attribute of this Compartment\n"
		"object.\n"
		"\n"
		"Returns the value of the 'compartmentType' attribute of this\n"
		"Compartment object as a string.\n"
		"\n"
		"Note: The 'compartmentType' attribute is only available in SBML Level\n"
		"2 Versions 2-4.\n"
		"\n"
		"See also isSetCompartmentType(), setCompartmentType(),\n"
		"unsetCompartmentType().\n"
		"\n"
		""},
	 { "Compartment_getSpatialDimensions", _wrap_Compartment_getSpatialDimensions, METH_O, "\n"
		"Compartment_getSpatialDimensions(Compartment self) -> unsigned int\n"
		"\n"
		"Get the number of spatial dimensions of this Compartment object.\n"
		"\n"
		"Returns the value of the 'spatialDimensions' attribute of this\n"
		"Compartment object as a long integereger.\n"
		"\n"
		"Note: In SBML Level 3, the data type of the 'spatialDimensions'\n"
		"attribute is 'float,' whereas in Level 2, it is 'integer.'  To avoid\n"
		"backward compatibility issues, libSBML provides two separate methods\n"
		"for obtaining the value as either an integer or a type 'float,' for\n"
		"models where it is relevant.\n"
		"\n"
		"See also getSpatialDimensionsAsDouble(), setSpatialDimensions(),\n"
		"isSetSpatialDimensions(), unsetSpatialDimensions().\n"
		"\n"
		""},
	 { "Compartment_getSpatialDimensionsAsDouble", _wrap_Compartment_getSpatialDimensionsAsDouble, METH_O, "\n"
		"Compartment_getSpatialDimensionsAsDouble(Compartment self) -> double\n"
		"\n"
		"Get the number of spatial dimensions of this Compartment object, as a\n"
		"double.\n"
		"\n"
		"Returns the value of the 'spatialDimensions' attribute of this\n"
		"Compartment object as a double, or 'NaN' if this model is not in SBML\n"
		"Level 3 format.\n"
		"\n"
		"Note: In SBML Level 3, the data type of the 'spatialDimensions'\n"
		"attribute is 'float,' whereas in Level 2, it is 'integer.'  To avoid\n"
		"backward compatibility issues, libSBML provides two separate methods\n"
		"for obtaining the value as either an integer or a type 'float,' for\n"
		"models where it is relevant.\n"
		"\n"
		"See also getSpatialDimensions(), setSpatialDimensions(),\n"
		"isSetSpatialDimensions(), unsetSpatialDimensions().\n"
		"\n"
		""},
	 { "Compartment_getSize", _wrap_Compartment_getSize, METH_O, "\n"
		"Compartment_getSize(Compartment self) -> double\n"
		"\n"
		"Get the size of this Compartment object.\n"
		"\n"
		"In SBML Level 1, compartments are always three-dimensional constructs\n"
		"and only have volumes, whereas in SBML Level 2 and higher,\n"
		"compartments may be other than three-dimensional, and therefore the\n"
		"'volume' attribute is named 'size' in Level 2 and above.  LibSBML\n"
		"provides both getSize() and getVolume() for easier support of\n"
		"different SBML Levels.\n"
		"\n"
		"Returns the value of the 'size' attribute ('volume' in Level 1) of\n"
		"this Compartment object as a floating-point number.\n"
		"\n"
		"Note: This method is identical to getVolume().\n"
		"\n"
		"See also getVolume(), isSetSize(), setSize(), unsetSize().\n"
		"\n"
		""},
	 { "Compartment_getVolume", _wrap_Compartment_getVolume, METH_O, "\n"
		"Compartment_getVolume(Compartment self) -> double\n"
		"\n"
		"Get the volume of this Compartment object.\n"
		"\n"
		"In SBML Level 1, compartments are always three-dimensional constructs\n"
		"and only have volumes, whereas in SBML Level 2 and higher,\n"
		"compartments may be other than three-dimensional, and therefore the\n"
		"'volume' attribute is named 'size' in Level 2 and above.  LibSBML\n"
		"provides both getSize() and getVolume() for easier support of\n"
		"different SBML Levels.\n"
		"\n"
		"Returns the value of the 'volume' attribute ('size' in Level 2) of\n"
		"this Compartment object, as a floating-point number.\n"
		"\n"
		"Note: The attribute 'volume' only exists by that name in SBML Level 1.\n"
		"In Level 2 and above, the equivalent attribute is named 'size'.  In\n"
		"SBML Level 1, a compartment's volume has a default value ('1.0)' and\n"
		"therefore methods such as isSetVolume() will always return 'True' for\n"
		"a Level 1 model.  In Level 2, a compartment's size (the equivalent of\n"
		"SBML Level 1's 'volume') is optional and has no default value, and\n"
		"therefore may or may not be set.\n"
		"\n"
		"Note: This method is identical to getSize().\n"
		"\n"
		"See also getSize(), isSetVolume(), setVolume(), unsetVolume().\n"
		"\n"
		""},
	 { "Compartment_getUnits", _wrap_Compartment_getUnits, METH_O, "\n"
		"Compartment_getUnits(Compartment self) -> string\n"
		"\n"
		"Get the units of this Compartment object's size.\n"
		"\n"
		"The value of an SBML compartment's 'units' attribute establishes the\n"
		"unit of measurement associated with the compartment's size.\n"
		"\n"
		"Returns the value of the 'units' attribute of this Compartment object,\n"
		"as a string.  An empty string indicates that no units have been\n"
		"assigned to the value of the size.\n"
		"\n"
		"Note: There is an important distinction to be made between no units\n"
		"assigned, and assuming a value without units has any specific unit\n"
		"such as dimensionless.  In SBML, default units are never attributed to\n"
		"numbers, and numbers without units are not automatically assumed to\n"
		"have the unit dimensionless.  Please consult the relevant SBML\n"
		"specification document for a more in-depth explanation of this topic\n"
		"and the SBML unit system.\n"
		"\n"
		"See also isSetUnits(), setUnits(), unsetUnits().\n"
		"\n"
		""},
	 { "Compartment_getOutside", _wrap_Compartment_getOutside, METH_O, "\n"
		"Compartment_getOutside(Compartment self) -> string\n"
		"\n"
		"Get the identifier, if any, of the Compartment object that is\n"
		"designated as being outside of this one.\n"
		"\n"
		"Returns the value of the 'outside' attribute of this Compartment\n"
		"object.\n"
		"\n"
		"Note: The 'outside' attribute is defined in SBML Level 1 and Level 2,\n"
		"but does not exist in SBML Level 3.\n"
		"\n"
		"See also isSetOutside(), setOutside(), unsetOutside().\n"
		"\n"
		""},
	 { "Compartment_getConstant", _wrap_Compartment_getConstant, METH_O, "\n"
		"Compartment_getConstant(Compartment self) -> bool\n"
		"\n"
		"Get the value of the 'constant' attribute of this Compartment object.\n"
		"\n"
		"Returns 'True' if this Compartment object's size is flagged as being\n"
		"constant, 'False' otherwise.\n"
		"\n"
		"See also isSetConstant(), setConstant().\n"
		"\n"
		""},
	 { "Compartment_isSetId", _wrap_Compartment_isSetId, METH_O, "\n"
		"Compartment_isSetId(Compartment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Compartment object's 'id' attribute\n"
		"is set.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is recommended that callers use\n"
		"isSetIdAttribute() instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),\n"
		"isSetIdAttribute().\n"
		"\n"
		""},
	 { "Compartment_isSetName", _wrap_Compartment_isSetName, METH_O, "\n"
		"Compartment_isSetName(Compartment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Compartment object's 'name'\n"
		"attribute is set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns 'True' if the 'name' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "Compartment_isSetCompartmentType", _wrap_Compartment_isSetCompartmentType, METH_O, "\n"
		"Compartment_isSetCompartmentType(Compartment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Compartment object's\n"
		"'compartmentType' attribute is set.\n"
		"\n"
		"Returns 'True' if the 'compartmentType' attribute of this Compartment\n"
		"is set, 'False' otherwise.\n"
		"\n"
		"Note: The 'compartmentType' attribute is only available in SBML Level\n"
		"2 Versions 2-4.\n"
		"\n"
		"See also setCompartmentType(), getCompartmentType(),\n"
		"unsetCompartmentType().\n"
		"\n"
		""},
	 { "Compartment_isSetSize", _wrap_Compartment_isSetSize, METH_O, "\n"
		"Compartment_isSetSize(Compartment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Compartment object's 'size'\n"
		"attribute is set.\n"
		"\n"
		"This method is similar but not identical to isSetVolume().  The latter\n"
		"should be used in the context of SBML Level 1 models instead of\n"
		"isSetSize() because isSetVolume() performs extra processing to take\n"
		"into account the difference in default values between SBML Levels 1\n"
		"and 2.\n"
		"\n"
		"Returns 'True' if the 'size' attribute ('volume' in Level 2) of this\n"
		"Compartment object is set, 'False' otherwise.\n"
		"\n"
		"See also isSetVolume(), setSize(), getSize(), unsetSize().\n"
		"\n"
		""},
	 { "Compartment_isSetVolume", _wrap_Compartment_isSetVolume, METH_O, "\n"
		"Compartment_isSetVolume(Compartment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Compartment object's 'volume'\n"
		"attribute is set.\n"
		"\n"
		"This method is similar but not identical to isSetSize().  The latter\n"
		"should not be used in the context of SBML Level 1 models because the\n"
		"present method performs extra processing to take into account the\n"
		"difference in default values between SBML Levels 1 and 2.\n"
		"\n"
		"Returns 'True' if the 'volume' attribute ('size' in Level 2 and above)\n"
		"of this Compartment object is set, 'False' otherwise.\n"
		"\n"
		"Note: The attribute 'volume' only exists by that name in SBML Level 1.\n"
		"In Level 2 and above, the equivalent attribute is named 'size'.  In\n"
		"SBML Level 1, a compartment's volume has a default value ('1.0)' and\n"
		"therefore methods such as isSetVolume() will always return 'True' for\n"
		"a Level 1 model.  In Level 2, a compartment's size (the equivalent of\n"
		"SBML Level 1's 'volume') is optional and has no default value, and\n"
		"therefore may or may not be set.\n"
		"\n"
		"See also isSetSize(), getVolume(), setVolume(), unsetVolume().\n"
		"\n"
		""},
	 { "Compartment_isSetUnits", _wrap_Compartment_isSetUnits, METH_O, "\n"
		"Compartment_isSetUnits(Compartment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Compartment object's 'units'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'units' attribute of this Compartment object is\n"
		"set, 'False' otherwise.\n"
		"\n"
		"Note: There is an important distinction to be made between no units\n"
		"assigned, and assuming a value without units has any specific unit\n"
		"such as dimensionless.  In SBML, default units are never attributed to\n"
		"numbers, and numbers without units are not automatically assumed to\n"
		"have the unit dimensionless.  Please consult the relevant SBML\n"
		"specification document for a more in-depth explanation of this topic\n"
		"and the SBML unit system.\n"
		"\n"
		"See also setUnits(), getUnits(), unsetUnits().\n"
		"\n"
		""},
	 { "Compartment_isSetOutside", _wrap_Compartment_isSetOutside, METH_O, "\n"
		"Compartment_isSetOutside(Compartment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Compartment object's 'outside'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'outside' attribute of this Compartment object\n"
		"is set, 'False' otherwise.\n"
		"\n"
		"Note: The 'outside' attribute is defined in SBML Level 1 and Level 2,\n"
		"but does not exist in SBML Level 3.\n"
		"\n"
		"See also getOutside(), setOutside(), unsetOutside().\n"
		"\n"
		""},
	 { "Compartment_isSetSpatialDimensions", _wrap_Compartment_isSetSpatialDimensions, METH_O, "\n"
		"Compartment_isSetSpatialDimensions(Compartment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Compartment object's\n"
		"'spatialDimensions' attribute is set.\n"
		"\n"
		"Returns 'True' if the 'spatialDimensions' attribute of this\n"
		"Compartment object is set, 'False' otherwise.\n"
		"\n"
		"See also getSpatialDimensions(), setSpatialDimensions(),\n"
		"unsetSpatialDimensions().\n"
		"\n"
		""},
	 { "Compartment_isSetConstant", _wrap_Compartment_isSetConstant, METH_O, "\n"
		"Compartment_isSetConstant(Compartment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Compartment object's 'constant'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'constant' attribute of this Compartment object\n"
		"is set, 'False' otherwise.\n"
		"\n"
		"See also getConstant(), setConstant().\n"
		"\n"
		""},
	 { "Compartment_setId", _wrap_Compartment_setId, METH_VARARGS, "\n"
		"Compartment_setId(Compartment self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this Compartment object.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this\n"
		"Compartment object. If the string is 'None,' this method will return\n"
		"LIBSBML_INVALID_ATTRIBUTE_VALUE.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"See also getId(), unsetId(), isSetId().\n"
		"\n"
		""},
	 { "Compartment_setName", _wrap_Compartment_setName, METH_VARARGS, "\n"
		"Compartment_setName(Compartment self, string name) -> int\n"
		"\n"
		"Sets the value of the 'name' attribute of this Compartment object.\n"
		"\n"
		"The string in 'name' is copied.\n"
		"\n"
		"Parameter 'name' is the new name for the SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Compartment_setCompartmentType", _wrap_Compartment_setCompartmentType, METH_VARARGS, "\n"
		"Compartment_setCompartmentType(Compartment self, string sid) -> int\n"
		"\n"
		"Sets the 'compartmentType' attribute of this Compartment object.\n"
		"\n"
		"Parameter 'sid' is the identifier of a CompartmentType object defined\n"
		"elsewhere in this Model. If the string is 'None,' this method will\n"
		"return LIBSBML_INVALID_ATTRIBUTE_VALUE.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The 'compartmentType' attribute is only available in SBML Level\n"
		"2 Versions 2-4.\n"
		"\n"
		"See also isSetCompartmentType(), getCompartmentType(),\n"
		"unsetCompartmentType().\n"
		"\n"
		""},
	 { "Compartment_setSpatialDimensions", _wrap_Compartment_setSpatialDimensions, METH_VARARGS, "\n"
		"Compartment_setSpatialDimensions(Compartment self, unsigned int value) -> int\n"
		"Compartment_setSpatialDimensions(Compartment self, double value) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setSpatialDimensions(double value)\n"
		"\n"
		"Sets the 'spatialDimensions' attribute of this Compartment object as a\n"
		"double.\n"
		"\n"
		"Parameter 'value' is a double indicating the number of dimensions of\n"
		"this compartment.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getSpatialDimensions(), isSetSpatialDimensions(),\n"
		"unsetSpatialDimensions().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setSpatialDimensions(long value)\n"
		"\n"
		"Sets the 'spatialDimensions' attribute of this Compartment object.\n"
		"\n"
		"Parameter 'value' is a long integereger indicating the number of\n"
		"dimensions of this compartment.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getSpatialDimensions(), isSetSpatialDimensions(),\n"
		"unsetSpatialDimensions().\n"
		"\n"
		""},
	 { "Compartment_setSize", _wrap_Compartment_setSize, METH_VARARGS, "\n"
		"Compartment_setSize(Compartment self, double value) -> int\n"
		"\n"
		"Sets the 'size' attribute (or 'volume' in SBML Level 1) of this\n"
		"Compartment object.\n"
		"\n"
		"Parameter 'value' is a 'float' representing the size of this\n"
		"compartment instance in whatever units are in effect for the\n"
		"compartment.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"Note: This method is identical to setVolume().\n"
		"\n"
		"See also setVolume(), getSize(), isSetSize(), unsetSize().\n"
		"\n"
		""},
	 { "Compartment_setVolume", _wrap_Compartment_setVolume, METH_VARARGS, "\n"
		"Compartment_setVolume(Compartment self, double value) -> int\n"
		"\n"
		"Sets the 'volume' attribute (or 'size' in SBML Level 2) of this\n"
		"Compartment object.\n"
		"\n"
		"This method is identical to setSize() and is provided for\n"
		"compatibility between SBML Level 1 and higher Levels of SBML.\n"
		"\n"
		"Parameter 'value' is a 'float' representing the volume of this\n"
		"compartment instance in whatever units are in effect for the\n"
		"compartment.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"Note: The attribute 'volume' only exists by that name in SBML Level 1.\n"
		"In Level 2 and above, the equivalent attribute is named 'size'.  In\n"
		"SBML Level 1, a compartment's volume has a default value ('1.0)' and\n"
		"therefore methods such as isSetVolume() will always return 'True' for\n"
		"a Level 1 model.  In Level 2, a compartment's size (the equivalent of\n"
		"SBML Level 1's 'volume') is optional and has no default value, and\n"
		"therefore may or may not be set.\n"
		"\n"
		"See also setSize(), getVolume(), isSetVolume(), unsetVolume().\n"
		"\n"
		""},
	 { "Compartment_setUnits", _wrap_Compartment_setUnits, METH_VARARGS, "\n"
		"Compartment_setUnits(Compartment self, string sid) -> int\n"
		"\n"
		"Sets the 'units' attribute of this Compartment object.\n"
		"\n"
		"Parameter 'sid' is the identifier of the defined units to use.  If\n"
		"'sid' is 'None,' then this method will return\n"
		"LIBSBML_INVALID_ATTRIBUTE_VALUE.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"See also isSetUnits(), getUnits(), unsetUnits().\n"
		"\n"
		""},
	 { "Compartment_setOutside", _wrap_Compartment_setOutside, METH_VARARGS, "\n"
		"Compartment_setOutside(Compartment self, string sid) -> int\n"
		"\n"
		"Sets the 'outside' attribute of this Compartment object.\n"
		"\n"
		"Parameter 'sid' is the identifier of a compartment that encloses this\n"
		"one. If 'sid' is 'None,' then this method will return\n"
		"LIBSBML_INVALID_ATTRIBUTE_VALUE.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: The 'outside' attribute is defined in SBML Level 1 and Level 2,\n"
		"but does not exist in SBML Level 3.\n"
		"\n"
		"See also isSetOutside(), getOutside(), unsetOutside().\n"
		"\n"
		""},
	 { "Compartment_setConstant", _wrap_Compartment_setConstant, METH_VARARGS, "\n"
		"Compartment_setConstant(Compartment self, bool value) -> int\n"
		"\n"
		"Sets the value of the 'constant' attribute of this Compartment object.\n"
		"\n"
		"Parameter 'value' is a boolean indicating whether the size/volume of\n"
		"this compartment should be considered constant ('True)' or variable\n"
		"('False).'\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also isSetConstant(), getConstant().\n"
		"\n"
		""},
	 { "Compartment_renameSIdRefs", _wrap_Compartment_renameSIdRefs, METH_VARARGS, "\n"
		"Compartment_renameSIdRefs(Compartment self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Compartment_renameUnitSIdRefs", _wrap_Compartment_renameUnitSIdRefs, METH_VARARGS, "\n"
		"Compartment_renameUnitSIdRefs(Compartment self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Compartment_unsetName", _wrap_Compartment_unsetName, METH_O, "\n"
		"Compartment_unsetName(Compartment self) -> int\n"
		"\n"
		"Unsets the value of the 'name' attribute of this Compartment object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getName(), setName(), isSetName().\n"
		"\n"
		""},
	 { "Compartment_unsetCompartmentType", _wrap_Compartment_unsetCompartmentType, METH_O, "\n"
		"Compartment_unsetCompartmentType(Compartment self) -> int\n"
		"\n"
		"Unsets the value of the 'compartmentType' attribute of this\n"
		"Compartment object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The 'compartmentType' attribute is only available in SBML Level\n"
		"2 Versions 2-4.\n"
		"\n"
		"See also setCompartmentType(), isSetCompartmentType(),\n"
		"getCompartmentType().\n"
		"\n"
		""},
	 { "Compartment_unsetConstant", _wrap_Compartment_unsetConstant, METH_O, "\n"
		"Compartment_unsetConstant(Compartment self) -> int\n"
		"\n"
		"Unsets the value of the 'constant' attribute of this Compartment\n"
		"object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also isSetConstant(), setConstant(), getConstant().\n"
		"\n"
		""},
	 { "Compartment_unsetSize", _wrap_Compartment_unsetSize, METH_O, "\n"
		"Compartment_unsetSize(Compartment self) -> int\n"
		"\n"
		"Unsets the value of the 'size' attribute of this Compartment object.\n"
		"\n"
		"In SBML Level 1, a compartment's volume has a default value ('1.0)'\n"
		"and therefore should always be set.  Calling this method on a Level 1\n"
		"model resets the value to '1.0' rather than actually unsetting it.  In\n"
		"Level 2, a compartment's 'size' is optional with no default value, and\n"
		"unsetting it will result in the compartment having no defined size.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method is identical to unsetVolume().\n"
		"\n"
		"See also unsetVolume(), getSize(), isSetSize(), setSize().\n"
		"\n"
		""},
	 { "Compartment_unsetVolume", _wrap_Compartment_unsetVolume, METH_O, "\n"
		"Compartment_unsetVolume(Compartment self) -> int\n"
		"\n"
		"Unsets the value of the 'volume' attribute of this Compartment object.\n"
		"\n"
		"This method is identical to unsetSize().  Please refer to that\n"
		"method's documentation for more information about its behavior.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The attribute 'volume' only exists by that name in SBML Level 1.\n"
		"In Level 2 and above, the equivalent attribute is named 'size'.  In\n"
		"SBML Level 1, a compartment's volume has a default value ('1.0)' and\n"
		"therefore methods such as isSetVolume() will always return 'True' for\n"
		"a Level 1 model.  In Level 2, a compartment's size (the equivalent of\n"
		"SBML Level 1's 'volume') is optional and has no default value, and\n"
		"therefore may or may not be set.\n"
		"\n"
		"See also unsetSize(), getVolume(), setVolume(), isSetVolume().\n"
		"\n"
		""},
	 { "Compartment_unsetUnits", _wrap_Compartment_unsetUnits, METH_O, "\n"
		"Compartment_unsetUnits(Compartment self) -> int\n"
		"\n"
		"Unsets the value of the 'units' attribute of this Compartment object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also isSetUnits(), setUnits(), getUnits().\n"
		"\n"
		""},
	 { "Compartment_unsetOutside", _wrap_Compartment_unsetOutside, METH_O, "\n"
		"Compartment_unsetOutside(Compartment self) -> int\n"
		"\n"
		"Unsets the value of the 'outside' attribute of this Compartment\n"
		"object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The 'outside' attribute is defined in SBML Level 1 and Level 2,\n"
		"but does not exist in SBML Level 3.\n"
		"\n"
		"See also isSetOutside(), getOutside(), setOutside().\n"
		"\n"
		""},
	 { "Compartment_unsetSpatialDimensions", _wrap_Compartment_unsetSpatialDimensions, METH_O, "\n"
		"Compartment_unsetSpatialDimensions(Compartment self) -> int\n"
		"\n"
		"Unsets the value of the 'spatialDimensions' attribute of this\n"
		"Compartment object.\n"
		"\n"
		"In SBML Levels prior to Level 3, compartments must always have a value\n"
		"for the number of dimensions.  Consequently, calling this method on a\n"
		"model of SBML Level 1-2 will result in a return value of\n"
		"LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: This function is only valid for SBML Level 3.\n"
		"\n"
		"See also getSpatialDimensions(), isSetSpatialDimensions(),\n"
		"setSpatialDimensions().\n"
		"\n"
		""},
	 { "Compartment_getDerivedUnitDefinition", _wrap_Compartment_getDerivedUnitDefinition, METH_VARARGS, "\n"
		"Compartment_getDerivedUnitDefinition(Compartment self) -> UnitDefinition\n"
		"Compartment_getDerivedUnitDefinition(Compartment self) -> UnitDefinition\n"
		"\n"
		"Constructs and returns a UnitDefinition that corresponds to the units\n"
		"of this Compartment object's designated size.\n"
		"\n"
		"Compartments in SBML have an attribute ('units') for declaring the\n"
		"units of measurement intended for the value of the compartment's size.\n"
		"In the absence of a value given for this attribute, the units are\n"
		"inherited from values either defined on the enclosing Model (in SBML\n"
		"Level 3) or in defaults (in SBML Level 2).  This method returns a\n"
		"UnitDefinition object based on how this compartment's units are\n"
		"interpreted according to the relevant SBML guidelines, or it returns\n"
		"'None' if no units have been declared and no defaults are defined by\n"
		"the relevant SBML specification.\n"
		"\n"
		"Note that unit declarations for Compartment objects  are specified in\n"
		"terms of the identifier of a unit, but this method returns an object ,\n"
		"not a unit identifier.  It does this by constructing an appropriate\n"
		"UnitDefinition object.  For SBML Level 2 models, it will do this even\n"
		"when the value of the 'units' attribute is one of the special SBML\n"
		"Level 2 unit identifiers ''substance',' ''volume',' ''area','\n"
		"''length'' or ''time'.'  Callers may find this useful in conjunction\n"
		"with the helper methods provided by the UnitDefinition class for\n"
		"comparing different UnitDefinition objects.\n"
		"\n"
		"Returns a UnitDefinition that expresses the units of this Compartment\n"
		"object, or 'None' if one cannot be constructed.\n"
		"\n"
		"Note: The libSBML system for unit analysis depends on the model as a\n"
		"whole.  In cases where the Compartment object has not yet been added\n"
		"to a model, or the model itself is incomplete, unit analysis is not\n"
		"possible, and consequently this method will return 'None.'\n"
		"\n"
		"See also isSetUnits(), getUnits().\n"
		"\n"
		""},
	 { "Compartment_getTypeCode", _wrap_Compartment_getTypeCode, METH_O, "\n"
		"Compartment_getTypeCode(Compartment self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_COMPARTMENT\n"
		"(default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "Compartment_getElementName", _wrap_Compartment_getElementName, METH_O, "\n"
		"Compartment_getElementName(Compartment self) -> string\n"
		"\n"
		"Returns the XML element name of this object\n"
		"\n"
		"For Compartment, the XML element name is always ''compartment'.'\n"
		"\n"
		"Returns the name of this element.\n"
		"\n"
		""},
	 { "Compartment_hasRequiredAttributes", _wrap_Compartment_hasRequiredAttributes, METH_O, "\n"
		"Compartment_hasRequiredAttributes(Compartment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"Compartment object have been set.\n"
		"\n"
		"The required attributes for a Compartment object are:\n"
		"\n"
		"* 'id' (or 'name' in SBML Level 1)\n"
		"\n"
		"* 'constant' (in SBML Level 3 only)\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Compartment_swigregister", Compartment_swigregister, METH_O, NULL},
	 { "Compartment_swiginit", Compartment_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfCompartments", _wrap_new_ListOfCompartments, METH_VARARGS, "\n"
		"ListOfCompartments(unsigned int level, unsigned int version)\n"
		"new_ListOfCompartments(SBMLNamespaces sbmlns) -> ListOfCompartments\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfCompartments(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfCompartments object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfCompartments object to be\n"
		"created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfCompartments(long level, long version)\n"
		"\n"
		"Creates a new ListOfCompartments object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfCompartments_clone", _wrap_ListOfCompartments_clone, METH_O, "\n"
		"ListOfCompartments_clone(ListOfCompartments self) -> ListOfCompartments\n"
		"\n"
		"Creates and returns a deep copy of this ListOfCompartments object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfCompartments object.\n"
		"\n"
		""},
	 { "ListOfCompartments_getItemTypeCode", _wrap_ListOfCompartments_getItemTypeCode, METH_O, "\n"
		"ListOfCompartments_getItemTypeCode(ListOfCompartments self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., Compartment objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for the objects contained in this ListOf\n"
		"instance: SBML_COMPARTMENT (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfCompartments_getElementName", _wrap_ListOfCompartments_getElementName, METH_O, "\n"
		"ListOfCompartments_getElementName(ListOfCompartments self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfCompartments, the XML element name is always\n"
		"''listOfCompartments'.'\n"
		"\n"
		"Returns the name of this element.\n"
		"\n"
		""},
	 { "ListOfCompartments_get", _wrap_ListOfCompartments_get, METH_VARARGS, "\n"
		"ListOfCompartments_get(ListOfCompartments self, unsigned int n) -> Compartment\n"
		"ListOfCompartments_get(ListOfCompartments self, unsigned int n) -> Compartment\n"
		"ListOfCompartments_get(ListOfCompartments self, string sid) -> Compartment\n"
		"ListOfCompartments_get(ListOfCompartments self, string sid) -> Compartment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Get a Compartment object from the ListOfCompartments.\n"
		"\n"
		"Parameter 'n' is the index number of the Compartment object to get.\n"
		"\n"
		"Returns the nth Compartment object in this ListOfCompartments. If the\n"
		"index 'n' is invalid, 'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Get a Compartment object from the ListOfCompartments based on its\n"
		"identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier of the\n"
		"Compartment object to get.\n"
		"\n"
		"Returns Compartment object in this ListOfCompartments with the given\n"
		"'sid' or 'None' if no such Compartment object exists.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfCompartments_remove", _wrap_ListOfCompartments_remove, METH_VARARGS, "\n"
		"ListOfCompartments_remove(ListOfCompartments self, unsigned int n) -> Compartment\n"
		"ListOfCompartments_remove(ListOfCompartments self, string sid) -> Compartment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfCompartments items and returns a\n"
		"pointer to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes item in this ListOfCompartments items with the given\n"
		"identifier.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"If none of the items in this list have the identifier 'sid', then\n"
		"'None' is returned.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  As mentioned above, the caller owns the\n"
		"returned item.\n"
		"\n"
		""},
	 { "delete_ListOfCompartments", _wrap_delete_ListOfCompartments, METH_O, "delete_ListOfCompartments(ListOfCompartments self)"},
	 { "ListOfCompartments_swigregister", ListOfCompartments_swigregister, METH_O, NULL},
	 { "ListOfCompartments_swiginit", ListOfCompartments_swiginit, METH_VARARGS, NULL},
	 { "delete_Species", _wrap_delete_Species, METH_O, "delete_Species(Species self)"},
	 { "new_Species", _wrap_new_Species, METH_VARARGS, "\n"
		"Species(unsigned int level, unsigned int version)\n"
		"Species(SBMLNamespaces sbmlns)\n"
		"new_Species(Species orig) -> Species\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Species(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new Species using the given SBMLNamespaces object 'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"It is worth emphasizing that although this constructor does not take\n"
		"an identifier argument, in SBML Level 2 and beyond, the 'id'\n"
		"(identifier) attribute of a Species is required to have a value. Thus,\n"
		"callers are cautioned to assign a value after calling this\n"
		"constructor.  Setting the identifier can be accomplished using the\n"
		"method Species.setId().\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Species(long level, long version)\n"
		"\n"
		"Creates a new Species using the given SBML 'level' and 'version'\n"
		"values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"Species.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this Species.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Species(Species orig)\n"
		"\n"
		"Copy constructor; creates a copy of this Species object.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "Species_clone", _wrap_Species_clone, METH_O, "\n"
		"Species_clone(Species self) -> Species\n"
		"\n"
		"Creates and returns a deep copy of this Species object.\n"
		"\n"
		"Returns the (deep) copy of this Species object.\n"
		"\n"
		""},
	 { "Species_initDefaults", _wrap_Species_initDefaults, METH_O, "\n"
		"Species_initDefaults(Species self)\n"
		"\n"
		"Initializes the fields of this Species object to 'typical' defaults\n"
		"values.\n"
		"\n"
		"The SBML Species component has slightly different aspects and default\n"
		"attribute values in different SBML Levels and Versions. This method\n"
		"sets the values to certain common defaults, based mostly on what they\n"
		"are in SBML Level 2.  Specifically:\n"
		"\n"
		"* Sets 'boundaryCondition' to 'False'\n"
		"\n"
		"* Sets 'constant' to 'False'\n"
		"\n"
		"* sets 'hasOnlySubstanceUnits' to 'False'\n"
		"\n"
		"* (Applies to Level 3 models only) Sets attribute 'substanceUnits'\n"
		"to 'mole'\n"
		"\n"
		""},
	 { "Species_getId", _wrap_Species_getId, METH_O, "\n"
		"Species_getId(Species self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this Species.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() function instead.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this Species.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Species_getName", _wrap_Species_getName, METH_O, "\n"
		"Species_getName(Species self) -> string\n"
		"\n"
		"Returns the value of the 'name' attribute of this Species object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns the name of this SBML object, or the empty string if not set\n"
		"or unsettable.\n"
		"\n"
		"See also getIdAttribute(), isSetName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "Species_getSpeciesType", _wrap_Species_getSpeciesType, METH_O, "\n"
		"Species_getSpeciesType(Species self) -> string\n"
		"\n"
		"Get the type of this Species object object.\n"
		"\n"
		"Returns the value of the 'speciesType' attribute of this Species as a\n"
		"string.\n"
		"\n"
		"Note: The 'speciesType' attribute is only available in SBML Level 2\n"
		"Versions 2-4.\n"
		"\n"
		""},
	 { "Species_getCompartment", _wrap_Species_getCompartment, METH_O, "\n"
		"Species_getCompartment(Species self) -> string\n"
		"\n"
		"Get the compartment in which this species is located.\n"
		"\n"
		"The compartment is designated by its identifier.\n"
		"\n"
		"Returns the value of the 'compartment' attribute of this Species\n"
		"object, as a string.\n"
		"\n"
		""},
	 { "Species_getInitialAmount", _wrap_Species_getInitialAmount, METH_O, "\n"
		"Species_getInitialAmount(Species self) -> double\n"
		"\n"
		"Get the value of the 'initialAmount' attribute.\n"
		"\n"
		"Returns the initialAmount of this Species, as a floating point number.\n"
		"\n"
		""},
	 { "Species_getInitialConcentration", _wrap_Species_getInitialConcentration, METH_O, "\n"
		"Species_getInitialConcentration(Species self) -> double\n"
		"\n"
		"Get the value of the 'initialConcentration' attribute.\n"
		"\n"
		"Returns the initialConcentration of this Species,, as a floating point\n"
		"number.\n"
		"\n"
		"Note: The attribute 'initialConcentration' is only available in SBML\n"
		"Level 2 and 3.  It does not exist on Species in Level 1.\n"
		"\n"
		""},
	 { "Species_getSubstanceUnits", _wrap_Species_getSubstanceUnits, METH_O, "\n"
		"Species_getSubstanceUnits(Species self) -> string\n"
		"\n"
		"Get the value of the 'substanceUnits' attribute.\n"
		"\n"
		"Returns the value of the 'substanceUnits' attribute of this Species,\n"
		"as a string.  An empty string indicates that no units have been\n"
		"assigned.\n"
		"\n"
		"Note: There is an important distinction to be made between no units\n"
		"assigned, and assuming a value without units has any specific unit\n"
		"such as dimensionless.  In SBML, default units are never attributed to\n"
		"numbers, and numbers without units are not automatically assumed to\n"
		"have the unit dimensionless.  Please consult the relevant SBML\n"
		"specification document for a more in-depth explanation of this topic\n"
		"and the SBML unit system.\n"
		"\n"
		"See also isSetSubstanceUnits(), setSubstanceUnits().\n"
		"\n"
		""},
	 { "Species_getSpatialSizeUnits", _wrap_Species_getSpatialSizeUnits, METH_O, "\n"
		"Species_getSpatialSizeUnits(Species self) -> string\n"
		"\n"
		"Get the value of the 'spatialSizeUnits' attribute.\n"
		"\n"
		"Returns the value of the 'spatialSizeUnits' attribute of this Species\n"
		"object, as a string.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"In versions of SBML Level 2 before Version 3, the class Species\n"
		"included an attribute called 'spatialSizeUnits', which allowed\n"
		"explicitly setting the units of size for initial concentration.  This\n"
		"attribute was removed in SBML Level 2 Version 3.  LibSBML retains this\n"
		"attribute for compatibility with older definitions of Level 2, but its\n"
		"use is strongly discouraged because it is incompatible with levels and\n"
		"versions of SBML beyond Level 2 Version 2.\n"
		"\n"
		""},
	 { "Species_getUnits", _wrap_Species_getUnits, METH_O, "\n"
		"Species_getUnits(Species self) -> string\n"
		"\n"
		"Get the value of the 'units' attribute.\n"
		"\n"
		"Returns the units of this Species (L1 only).\n"
		"\n"
		"Note: The 'units' attribute is defined only in SBML Level 1.  In SBML\n"
		"Level 2 and Level 3, it has been replaced by a combination of\n"
		"'substanceUnits' and the units of the Compartment object in which a\n"
		"species is located.  In SBML Level 2 Versions 1-2, an additional\n"
		"attribute 'spatialSizeUnits' helps determine the units of the species\n"
		"quantity, but this attribute was removed in later versions of SBML\n"
		"Level 2.\n"
		"\n"
		""},
	 { "Species_getHasOnlySubstanceUnits", _wrap_Species_getHasOnlySubstanceUnits, METH_O, "\n"
		"Species_getHasOnlySubstanceUnits(Species self) -> bool\n"
		"\n"
		"Get the value of the 'hasOnlySubstanceUnits' attribute.\n"
		"\n"
		"Returns 'True' if this Species' 'hasOnlySubstanceUnits' attribute\n"
		"value is 'True,' 'False' otherwise.\n"
		"\n"
		"Note: The 'hasOnlySubstanceUnits' attribute does not exist in SBML\n"
		"Level 1.\n"
		"\n"
		""},
	 { "Species_getBoundaryCondition", _wrap_Species_getBoundaryCondition, METH_O, "\n"
		"Species_getBoundaryCondition(Species self) -> bool\n"
		"\n"
		"Get the value of the 'boundaryCondition' attribute.\n"
		"\n"
		"Returns 'True' if this Species' 'boundaryCondition' attribute value is\n"
		"'True,' 'False' otherwise.\n"
		"\n"
		""},
	 { "Species_getCharge", _wrap_Species_getCharge, METH_O, "\n"
		"Species_getCharge(Species self) -> int\n"
		"\n"
		"Get the value of the 'charge' attribute.\n"
		"\n"
		"Returns the charge of this Species object.\n"
		"\n"
		"Note: Beginning in SBML Level 2 Version 2, the 'charge' attribute on\n"
		"Species is deprecated and in SBML Level 3 it does not exist at all.\n"
		"Its use strongly discouraged.  Its presence is considered a misfeature\n"
		"in earlier definitions of SBML because its implications for the\n"
		"mathematics of a model were never defined, and in any case, no known\n"
		"modeling system ever used it.  Instead, models take account of charge\n"
		"values directly in their definitions of species by (for example)\n"
		"having separate species identities for the charged and uncharged\n"
		"versions of the same species.  This allows the condition to affect\n"
		"model mathematics directly.  LibSBML retains this method for easier\n"
		"compatibility with SBML Level 1.\n"
		"\n"
		""},
	 { "Species_getConstant", _wrap_Species_getConstant, METH_O, "\n"
		"Species_getConstant(Species self) -> bool\n"
		"\n"
		"Get the value of the 'constant' attribute.\n"
		"\n"
		"Returns 'True' if this Species's 'constant' attribute value is 'True,'\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The attribute 'constant' is only available in SBML Levels 2 and\n"
		"3.  It does not exist on Species in Level 1.\n"
		"\n"
		""},
	 { "Species_getConversionFactor", _wrap_Species_getConversionFactor, METH_O, "\n"
		"Species_getConversionFactor(Species self) -> string\n"
		"\n"
		"Get the value of the 'conversionFactor' attribute.\n"
		"\n"
		"Returns the conversionFactor of this Species, as a string.\n"
		"\n"
		"Note: The 'conversionFactor' attribute was introduced in SBML Level 3.\n"
		"It does not exist on Species in SBML Levels 1 and 2.\n"
		"\n"
		""},
	 { "Species_isSetId", _wrap_Species_isSetId, METH_O, "\n"
		"Species_isSetId(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's 'id' attribute is\n"
		"set.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is recommended that callers use\n"
		"isSetIdAttribute() instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),\n"
		"isSetIdAttribute().\n"
		"\n"
		""},
	 { "Species_isSetName", _wrap_Species_isSetName, METH_O, "\n"
		"Species_isSetName(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's 'name' attribute\n"
		"is set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns 'True' if the 'name' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "Species_isSetSpeciesType", _wrap_Species_isSetSpeciesType, METH_O, "\n"
		"Species_isSetSpeciesType(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's 'speciesType'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'speciesType' attribute of this Species is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The 'speciesType' attribute is only available in SBML Level 2\n"
		"Versions 2-4.\n"
		"\n"
		""},
	 { "Species_isSetCompartment", _wrap_Species_isSetCompartment, METH_O, "\n"
		"Species_isSetCompartment(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's 'compartment'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'compartment' attribute of this Species is set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "Species_isSetInitialAmount", _wrap_Species_isSetInitialAmount, METH_O, "\n"
		"Species_isSetInitialAmount(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's 'initialAmount'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'initialAmount' attribute of this Species is\n"
		"set, 'False' otherwise.\n"
		"\n"
		"Note: In SBML Level 1, Species' 'initialAmount' is required and\n"
		"therefore should always be set.  (However, in Level 1, the attribute\n"
		"has no default value either, so this method will not return 'True'\n"
		"until a value has been assigned.)  In SBML Level 2, 'initialAmount' is\n"
		"optional and as such may or may not be set.\n"
		"\n"
		""},
	 { "Species_isSetInitialConcentration", _wrap_Species_isSetInitialConcentration, METH_O, "\n"
		"Species_isSetInitialConcentration(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's\n"
		"'initialConcentration' attribute is set.\n"
		"\n"
		"Returns 'True' if the 'initialConcentration' attribute of this Species\n"
		"is set, 'False' otherwise.\n"
		"\n"
		"Note: The attribute 'initialConcentration' is only available in SBML\n"
		"Level 2 and 3.  It does not exist on Species in Level 1.\n"
		"\n"
		""},
	 { "Species_isSetSubstanceUnits", _wrap_Species_isSetSubstanceUnits, METH_O, "\n"
		"Species_isSetSubstanceUnits(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's 'substanceUnits'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'substanceUnits' attribute of this Species is\n"
		"set, 'False' otherwise.\n"
		"\n"
		""},
	 { "Species_isSetSpatialSizeUnits", _wrap_Species_isSetSpatialSizeUnits, METH_O, "\n"
		"Species_isSetSpatialSizeUnits(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's 'spatialSizeUnits'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'spatialSizeUnits' attribute of this Species is\n"
		"set, 'False' otherwise.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"In versions of SBML Level 2 before Version 3, the class Species\n"
		"included an attribute called 'spatialSizeUnits', which allowed\n"
		"explicitly setting the units of size for initial concentration.  This\n"
		"attribute was removed in SBML Level 2 Version 3.  LibSBML retains this\n"
		"attribute for compatibility with older definitions of Level 2, but its\n"
		"use is strongly discouraged because it is incompatible with levels and\n"
		"versions of SBML beyond Level 2 Version 2.\n"
		"\n"
		""},
	 { "Species_isSetUnits", _wrap_Species_isSetUnits, METH_O, "\n"
		"Species_isSetUnits(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's 'units' attribute\n"
		"is set.\n"
		"\n"
		"Returns 'True' if the 'units' attribute of this Species is set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "Species_isSetCharge", _wrap_Species_isSetCharge, METH_O, "\n"
		"Species_isSetCharge(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's 'charge' attribute\n"
		"is set.\n"
		"\n"
		"Returns 'True' if the 'charge' attribute of this Species is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Beginning in SBML Level 2 Version 2, the 'charge' attribute on\n"
		"Species is deprecated and in SBML Level 3 it does not exist at all.\n"
		"Its use strongly discouraged.  Its presence is considered a misfeature\n"
		"in earlier definitions of SBML because its implications for the\n"
		"mathematics of a model were never defined, and in any case, no known\n"
		"modeling system ever used it.  Instead, models take account of charge\n"
		"values directly in their definitions of species by (for example)\n"
		"having separate species identities for the charged and uncharged\n"
		"versions of the same species.  This allows the condition to affect\n"
		"model mathematics directly.  LibSBML retains this method for easier\n"
		"compatibility with SBML Level 1.\n"
		"\n"
		""},
	 { "Species_isSetConversionFactor", _wrap_Species_isSetConversionFactor, METH_O, "\n"
		"Species_isSetConversionFactor(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's 'conversionFactor'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'conversionFactor' attribute of this Species is\n"
		"set, 'False' otherwise.\n"
		"\n"
		"Note: The 'conversionFactor' attribute was introduced in SBML Level 3.\n"
		"It does not exist on Species in SBML Levels 1 and 2.\n"
		"\n"
		""},
	 { "Species_isSetBoundaryCondition", _wrap_Species_isSetBoundaryCondition, METH_O, "\n"
		"Species_isSetBoundaryCondition(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's\n"
		"'boundaryCondition' attribute is set.\n"
		"\n"
		"Returns 'True' if the 'boundaryCondition' attribute of this Species is\n"
		"set, 'False' otherwise.\n"
		"\n"
		""},
	 { "Species_isSetHasOnlySubstanceUnits", _wrap_Species_isSetHasOnlySubstanceUnits, METH_O, "\n"
		"Species_isSetHasOnlySubstanceUnits(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's\n"
		"'hasOnlySubstanceUnits' attribute is set.\n"
		"\n"
		"Returns 'True' if the 'hasOnlySubstanceUnits' attribute of this\n"
		"Species is set, 'False' otherwise.\n"
		"\n"
		"Note: The 'hasOnlySubstanceUnits' attribute does not exist in SBML\n"
		"Level 1.\n"
		"\n"
		""},
	 { "Species_isSetConstant", _wrap_Species_isSetConstant, METH_O, "\n"
		"Species_isSetConstant(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Species object's 'constant'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'constant' attribute of this Species is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The attribute 'constant' is only available in SBML Levels 2 and\n"
		"3.  It does not exist on Species in Level 1.\n"
		"\n"
		""},
	 { "Species_setId", _wrap_Species_setId, METH_VARARGS, "\n"
		"Species_setId(Species self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this Species.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Species_setName", _wrap_Species_setName, METH_VARARGS, "\n"
		"Species_setName(Species self, string name) -> int\n"
		"\n"
		"Sets the value of the 'name' attribute of this Species.\n"
		"\n"
		"The string in 'name' is copied.\n"
		"\n"
		"Parameter 'name' is the new name for the SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Species_setSpeciesType", _wrap_Species_setSpeciesType, METH_VARARGS, "\n"
		"Species_setSpeciesType(Species self, string sid) -> int\n"
		"\n"
		"Sets the 'speciesType' attribute of this Species object.\n"
		"\n"
		"Parameter 'sid' is the identifier of a SpeciesType object defined\n"
		"elsewhere in this Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The 'speciesType' attribute is only available in SBML Level 2\n"
		"Versions 2-4.\n"
		"\n"
		""},
	 { "Species_setCompartment", _wrap_Species_setCompartment, METH_VARARGS, "\n"
		"Species_setCompartment(Species self, string sid) -> int\n"
		"\n"
		"Sets the 'compartment' attribute of this Species object.\n"
		"\n"
		"Parameter 'sid' is the identifier of a Compartment object defined\n"
		"elsewhere in this Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Species_setInitialAmount", _wrap_Species_setInitialAmount, METH_VARARGS, "\n"
		"Species_setInitialAmount(Species self, double value) -> int\n"
		"\n"
		"Sets the 'initialAmount' attribute of this Species and marks the field\n"
		"as set.\n"
		"\n"
		"This method also unsets the 'initialConcentration' attribute.\n"
		"\n"
		"Parameter 'value' is the value to which the 'initialAmount' attribute\n"
		"should be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "Species_setInitialConcentration", _wrap_Species_setInitialConcentration, METH_VARARGS, "\n"
		"Species_setInitialConcentration(Species self, double value) -> int\n"
		"\n"
		"Sets the 'initialConcentration' attribute of this Species and marks\n"
		"the field as set.\n"
		"\n"
		"This method also unsets the 'initialAmount' attribute.\n"
		"\n"
		"Parameter 'value' is the value to which the 'initialConcentration'\n"
		"attribute should be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The attribute 'initialConcentration' is only available in SBML\n"
		"Level 2 and 3.  It does not exist on Species in Level 1.\n"
		"\n"
		""},
	 { "Species_setSubstanceUnits", _wrap_Species_setSubstanceUnits, METH_VARARGS, "\n"
		"Species_setSubstanceUnits(Species self, string sid) -> int\n"
		"\n"
		"Sets the 'substanceUnits' attribute of this Species object.\n"
		"\n"
		"Parameter 'sid' is the identifier of the unit to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Species_setSpatialSizeUnits", _wrap_Species_setSpatialSizeUnits, METH_VARARGS, "\n"
		"Species_setSpatialSizeUnits(Species self, string sid) -> int\n"
		"\n"
		"(SBML Level 2 Versions 1-2) Sets the 'spatialSizeUnits' attribute of\n"
		"this Species object.\n"
		"\n"
		"Parameter 'sid' is the identifier of the unit to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"WARNING:\n"
		"\n"
		"In versions of SBML Level 2 before Version 3, the class Species\n"
		"included an attribute called 'spatialSizeUnits', which allowed\n"
		"explicitly setting the units of size for initial concentration.  This\n"
		"attribute was removed in SBML Level 2 Version 3.  LibSBML retains this\n"
		"attribute for compatibility with older definitions of Level 2, but its\n"
		"use is strongly discouraged because it is incompatible with levels and\n"
		"versions of SBML beyond Level 2 Version 2.\n"
		"\n"
		""},
	 { "Species_setUnits", _wrap_Species_setUnits, METH_VARARGS, "\n"
		"Species_setUnits(Species self, string sname) -> int\n"
		"\n"
		"(SBML Level 1 only) Sets the units of this Species object.\n"
		"\n"
		"Parameter 'sname' is the identifier of the unit to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Species_setHasOnlySubstanceUnits", _wrap_Species_setHasOnlySubstanceUnits, METH_VARARGS, "\n"
		"Species_setHasOnlySubstanceUnits(Species self, bool value) -> int\n"
		"\n"
		"Sets the 'hasOnlySubstanceUnits' attribute of this Species object.\n"
		"\n"
		"Parameter 'value' is boolean value for the 'hasOnlySubstanceUnits'\n"
		"attribute.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The 'hasOnlySubstanceUnits' attribute does not exist in SBML\n"
		"Level 1.\n"
		"\n"
		""},
	 { "Species_setBoundaryCondition", _wrap_Species_setBoundaryCondition, METH_VARARGS, "\n"
		"Species_setBoundaryCondition(Species self, bool value) -> int\n"
		"\n"
		"Sets the 'boundaryCondition' attribute of this Species object.\n"
		"\n"
		"Parameter 'value' is boolean value for the 'boundaryCondition'\n"
		"attribute.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "Species_setCharge", _wrap_Species_setCharge, METH_VARARGS, "\n"
		"Species_setCharge(Species self, int value) -> int\n"
		"\n"
		"Sets the 'charge' attribute of this Species object.\n"
		"\n"
		"Parameter 'value' is an integer to which to set the 'charge' to.\n"
		"\n"
		"Note: Beginning in SBML Level 2 Version 2, the 'charge' attribute on\n"
		"Species is deprecated and in SBML Level 3 it does not exist at all.\n"
		"Its use strongly discouraged.  Its presence is considered a misfeature\n"
		"in earlier definitions of SBML because its implications for the\n"
		"mathematics of a model were never defined, and in any case, no known\n"
		"modeling system ever used it.  Instead, models take account of charge\n"
		"values directly in their definitions of species by (for example)\n"
		"having separate species identities for the charged and uncharged\n"
		"versions of the same species.  This allows the condition to affect\n"
		"model mathematics directly.  LibSBML retains this method for easier\n"
		"compatibility with SBML Level 1.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		""},
	 { "Species_setConstant", _wrap_Species_setConstant, METH_VARARGS, "\n"
		"Species_setConstant(Species self, bool value) -> int\n"
		"\n"
		"Sets the 'constant' attribute of this Species object.\n"
		"\n"
		"Parameter 'value' is a boolean value for the 'constant' attribute.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The attribute 'constant' is only available in SBML Levels 2 and\n"
		"3.  It does not exist on Species in Level 1.\n"
		"\n"
		""},
	 { "Species_setConversionFactor", _wrap_Species_setConversionFactor, METH_VARARGS, "\n"
		"Species_setConversionFactor(Species self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'conversionFactor' attribute of this Species\n"
		"object.\n"
		"\n"
		"The string in 'sid' is copied.\n"
		"\n"
		"Parameter 'sid' is the new conversionFactor for the Species.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: The 'conversionFactor' attribute was introduced in SBML Level 3.\n"
		"It does not exist on Species in SBML Levels 1 and 2.\n"
		"\n"
		""},
	 { "Species_unsetName", _wrap_Species_unsetName, METH_O, "\n"
		"Species_unsetName(Species self) -> int\n"
		"\n"
		"Unsets the value of the 'name' attribute of this Species object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getName(), setName(), isSetName().\n"
		"\n"
		""},
	 { "Species_unsetConstant", _wrap_Species_unsetConstant, METH_O, "\n"
		"Species_unsetConstant(Species self) -> int\n"
		"\n"
		"Unsets the value of the 'constant' attribute of this Species object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also isSetConstant(), setConstant(), getConstant().\n"
		"\n"
		""},
	 { "Species_unsetSpeciesType", _wrap_Species_unsetSpeciesType, METH_O, "\n"
		"Species_unsetSpeciesType(Species self) -> int\n"
		"\n"
		"Unsets the 'speciesType' attribute value of this Species object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The attribute 'speciesType' is only available in SBML Level 2\n"
		"Versions 2-4.\n"
		"\n"
		""},
	 { "Species_unsetInitialAmount", _wrap_Species_unsetInitialAmount, METH_O, "\n"
		"Species_unsetInitialAmount(Species self) -> int\n"
		"\n"
		"Unsets the 'initialAmount' attribute value of this Species object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Species_unsetInitialConcentration", _wrap_Species_unsetInitialConcentration, METH_O, "\n"
		"Species_unsetInitialConcentration(Species self) -> int\n"
		"\n"
		"Unsets the 'initialConcentration' attribute value of this Species\n"
		"object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The attribute 'initialConcentration' is only available in SBML\n"
		"Level 2 and 3.  It does not exist on Species in Level 1.\n"
		"\n"
		""},
	 { "Species_unsetSubstanceUnits", _wrap_Species_unsetSubstanceUnits, METH_O, "\n"
		"Species_unsetSubstanceUnits(Species self) -> int\n"
		"\n"
		"Unsets the 'substanceUnits' attribute value of this Species object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Species_unsetSpatialSizeUnits", _wrap_Species_unsetSpatialSizeUnits, METH_O, "\n"
		"Species_unsetSpatialSizeUnits(Species self) -> int\n"
		"\n"
		"Unsets the 'spatialSizeUnits' attribute value of this Species object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"WARNING:\n"
		"\n"
		"In versions of SBML Level 2 before Version 3, the class Species\n"
		"included an attribute called 'spatialSizeUnits', which allowed\n"
		"explicitly setting the units of size for initial concentration.  This\n"
		"attribute was removed in SBML Level 2 Version 3.  LibSBML retains this\n"
		"attribute for compatibility with older definitions of Level 2, but its\n"
		"use is strongly discouraged because it is incompatible with levels and\n"
		"versions of SBML beyond Level 2 Version 2.\n"
		"\n"
		""},
	 { "Species_unsetUnits", _wrap_Species_unsetUnits, METH_O, "\n"
		"Species_unsetUnits(Species self) -> int\n"
		"\n"
		"Unsets the 'units' attribute value of this Species object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Species_unsetCharge", _wrap_Species_unsetCharge, METH_O, "\n"
		"Species_unsetCharge(Species self) -> int\n"
		"\n"
		"Unsets the 'charge' attribute value of this Species object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: Beginning in SBML Level 2 Version 2, the 'charge' attribute on\n"
		"Species is deprecated and in SBML Level 3 it does not exist at all.\n"
		"Its use strongly discouraged.  Its presence is considered a misfeature\n"
		"in earlier definitions of SBML because its implications for the\n"
		"mathematics of a model were never defined, and in any case, no known\n"
		"modeling system ever used it.  Instead, models take account of charge\n"
		"values directly in their definitions of species by (for example)\n"
		"having separate species identities for the charged and uncharged\n"
		"versions of the same species.  This allows the condition to affect\n"
		"model mathematics directly.  LibSBML retains this method for easier\n"
		"compatibility with SBML Level 1.\n"
		"\n"
		""},
	 { "Species_unsetConversionFactor", _wrap_Species_unsetConversionFactor, METH_O, "\n"
		"Species_unsetConversionFactor(Species self) -> int\n"
		"\n"
		"Unsets the 'conversionFactor' attribute value of this Species object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The 'conversionFactor' attribute was introduced in SBML Level 3.\n"
		"It does not exist on Species in SBML Levels 1 and 2.\n"
		"\n"
		""},
	 { "Species_unsetCompartment", _wrap_Species_unsetCompartment, METH_O, "\n"
		"Species_unsetCompartment(Species self) -> int\n"
		"\n"
		"Unsets the 'compartment' attribute value of this Species object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Species_unsetBoundaryCondition", _wrap_Species_unsetBoundaryCondition, METH_O, "\n"
		"Species_unsetBoundaryCondition(Species self) -> int\n"
		"\n"
		"Unsets the 'boundaryCondition' attribute value of this Species object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Species_unsetHasOnlySubstanceUnits", _wrap_Species_unsetHasOnlySubstanceUnits, METH_O, "\n"
		"Species_unsetHasOnlySubstanceUnits(Species self) -> int\n"
		"\n"
		"Unsets the 'hasOnlySubstanceUnits' attribute value of this Species\n"
		"object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Species_getDerivedUnitDefinition", _wrap_Species_getDerivedUnitDefinition, METH_VARARGS, "\n"
		"Species_getDerivedUnitDefinition(Species self) -> UnitDefinition\n"
		"Species_getDerivedUnitDefinition(Species self) -> UnitDefinition\n"
		"\n"
		"Constructs and returns a UnitDefinition that corresponds to the units\n"
		"of this Species' amount or concentration.\n"
		"\n"
		"Species in SBML have an attribute ('substanceUnits') for declaring the\n"
		"units of measurement intended for the species' amount or concentration\n"
		"(depending on which one applies).  In the absence of a value given for\n"
		"'substanceUnits', the units are taken from the enclosing Model's\n"
		"definition of ''substance'' or ''substance'/(size' of the compartment)\n"
		"in which the species is located, or finally, if these are not\n"
		"redefined by the Model, the relevant SBML default units for those\n"
		"quantities.  Following that procedure, the method\n"
		"getDerivedUnitDefinition() returns a UnitDefinition based on the\n"
		"interpreted units of this species's amount or concentration.\n"
		"\n"
		"Note that the functionality that facilitates unit analysis depends  on\n"
		"the model as a whole.  Thus, in cases where the object has not  been\n"
		"added to a model or the model itself is incomplete, unit analysis is\n"
		"not possible and this method will return 'None.'\n"
		"\n"
		"Note also that unit declarations for Species are in terms of the\n"
		"identifier of a unit, but this method returns a UnitDefinition object,\n"
		"not a unit identifier.  It does this by constructing an appropriate\n"
		"UnitDefinition.  Callers may find this particularly useful when used\n"
		"in conjunction with the helper methods on UnitDefinition for comparing\n"
		"different UnitDefinition objects.\n"
		"\n"
		"In SBML Level 2 specifications prior to Version 3, Species includes an\n"
		"additional attribute named 'spatialSizeUnits', which allows explicitly\n"
		"setting the units of size for initial concentration. The\n"
		"getDerivedUnitDefinition() takes this into account for models\n"
		"expressed in SBML Level 2 Versions 1 and 2.\n"
		"\n"
		"Returns a UnitDefinition that expresses the units of this  Species, or\n"
		"'None' if one cannot be constructed.\n"
		"\n"
		"See also getSubstanceUnits().\n"
		"\n"
		""},
	 { "Species_getTypeCode", _wrap_Species_getTypeCode, METH_O, "\n"
		"Species_getTypeCode(Species self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_SPECIES (default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "Species_getElementName", _wrap_Species_getElementName, METH_O, "\n"
		"Species_getElementName(Species self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for Species, is\n"
		"always ''species'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''species'.'\n"
		"\n"
		""},
	 { "Species_hasRequiredAttributes", _wrap_Species_hasRequiredAttributes, METH_O, "\n"
		"Species_hasRequiredAttributes(Species self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"Species object have been set.\n"
		"\n"
		"The required attributes for a Species object are:\n"
		"\n"
		"* 'id' (or 'name' in SBML Level 1)\n"
		"\n"
		"* 'compartment'\n"
		"\n"
		"* 'initialAmount' (required in SBML Level 1 only; optional\n"
		"otherwise)\n"
		"\n"
		"* 'hasOnlySubstanceUnits' (required in SBML Level 3; optional in\n"
		"SBML Level 2)\n"
		"\n"
		"* 'boundaryCondition' (required in SBML Level 3; optional in Levels\n"
		"1 and 2)\n"
		"\n"
		"* 'constant' (required in SBML Level 3; optional in SBML Level 2)\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Species_renameSIdRefs", _wrap_Species_renameSIdRefs, METH_VARARGS, "\n"
		"Species_renameSIdRefs(Species self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Species_renameUnitSIdRefs", _wrap_Species_renameUnitSIdRefs, METH_VARARGS, "\n"
		"Species_renameUnitSIdRefs(Species self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Species_swigregister", Species_swigregister, METH_O, NULL},
	 { "Species_swiginit", Species_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfSpecies", _wrap_new_ListOfSpecies, METH_VARARGS, "\n"
		"ListOfSpecies(unsigned int level, unsigned int version)\n"
		"new_ListOfSpecies(SBMLNamespaces sbmlns) -> ListOfSpecies\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfSpecies(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfSpecies object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfSpecies object to be\n"
		"created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfSpecies(long level, long version)\n"
		"\n"
		"Creates a new ListOfSpecies object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfSpecies_clone", _wrap_ListOfSpecies_clone, METH_O, "\n"
		"ListOfSpecies_clone(ListOfSpecies self) -> ListOfSpecies\n"
		"\n"
		"Creates and returns a deep copy of this ListOfSpecies object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfSpecies object.\n"
		"\n"
		""},
	 { "ListOfSpecies_getItemTypeCode", _wrap_ListOfSpecies_getItemTypeCode, METH_O, "\n"
		"ListOfSpecies_getItemTypeCode(ListOfSpecies self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., Species objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for objects contained in this list:\n"
		"SBML_SPECIES (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfSpecies_getElementName", _wrap_ListOfSpecies_getElementName, METH_O, "\n"
		"ListOfSpecies_getElementName(ListOfSpecies self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfSpeciess, the XML element name is ''listOfSpeciess'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfSpeciess'.'\n"
		"\n"
		""},
	 { "ListOfSpecies_get", _wrap_ListOfSpecies_get, METH_VARARGS, "\n"
		"ListOfSpecies_get(ListOfSpecies self, unsigned int n) -> Species\n"
		"ListOfSpecies_get(ListOfSpecies self, unsigned int n) -> Species\n"
		"ListOfSpecies_get(ListOfSpecies self, string sid) -> Species\n"
		"ListOfSpecies_get(ListOfSpecies self, string sid) -> Species\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Get a Species from the ListOfSpecies.\n"
		"\n"
		"Parameter 'n' is the index number of the Species to get.\n"
		"\n"
		"Returns the nth Species in this ListOfSpecies. If the index 'n' is\n"
		"invalid, 'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Get a Species from the ListOfSpecies based on its identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier  of the\n"
		"Species to get.\n"
		"\n"
		"Returns Species in this ListOfSpecies with the given 'sid' or 'None'\n"
		"if no such Species exists.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfSpecies_remove", _wrap_ListOfSpecies_remove, METH_VARARGS, "\n"
		"ListOfSpecies_remove(ListOfSpecies self, unsigned int n) -> Species\n"
		"ListOfSpecies_remove(ListOfSpecies self, string sid) -> Species\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfSpeciess items and returns a\n"
		"pointer to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes item in this ListOfSpeciess items with the given identifier.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"If none of the items in this list have the identifier 'sid', then\n"
		"'None' is returned.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  As mentioned above, the caller owns the\n"
		"returned item.\n"
		"\n"
		""},
	 { "delete_ListOfSpecies", _wrap_delete_ListOfSpecies, METH_O, "delete_ListOfSpecies(ListOfSpecies self)"},
	 { "ListOfSpecies_swigregister", ListOfSpecies_swigregister, METH_O, NULL},
	 { "ListOfSpecies_swiginit", ListOfSpecies_swiginit, METH_VARARGS, NULL},
	 { "delete_Parameter", _wrap_delete_Parameter, METH_O, "delete_Parameter(Parameter self)"},
	 { "new_Parameter", _wrap_new_Parameter, METH_VARARGS, "\n"
		"Parameter(unsigned int level, unsigned int version)\n"
		"Parameter(SBMLNamespaces sbmlns)\n"
		"new_Parameter(Parameter orig) -> Parameter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Parameter(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new Parameter using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"It is worth emphasizing that although this constructor does not take\n"
		"an identifier argument, in SBML Level 2 and beyond, the 'id'\n"
		"(identifier) attribute of a Parameter is required to have a value.\n"
		"Thus, callers are cautioned to assign a value after calling this\n"
		"constructor if no identifier is provided as an argument.  Setting the\n"
		"identifier can be accomplished using the method setId().\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Parameter(long level, long version)\n"
		"\n"
		"Creates a new Parameter using the given SBML 'level' and 'version'\n"
		"values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"Parameter.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this Parameter.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Parameter(Parameter orig)\n"
		"\n"
		"Copy constructor; creates a copy of a Parameter.\n"
		"\n"
		"Parameter 'orig' is the Parameter instance to copy.\n"
		"\n"
		""},
	 { "Parameter_clone", _wrap_Parameter_clone, METH_O, "\n"
		"Parameter_clone(Parameter self) -> Parameter\n"
		"\n"
		"Creates and returns a deep copy of this Parameter object.\n"
		"\n"
		"Returns the (deep) copy of this Parameter object.\n"
		"\n"
		""},
	 { "Parameter_initDefaults", _wrap_Parameter_initDefaults, METH_O, "\n"
		"Parameter_initDefaults(Parameter self)\n"
		"\n"
		"Initializes the fields of this Parameter object to 'typical' defaults\n"
		"values.\n"
		"\n"
		"The SBML Parameter component has slightly different aspects and\n"
		"default attribute values in different SBML Levels and Versions.  Many\n"
		"SBML object classes defined by libSBML have an initDefaults() method\n"
		"to set the values to certain common defaults, based mostly on what\n"
		"they are in SBML Level 2.  In the case of Parameter, this method only\n"
		"sets the value of the 'constant' attribute to 'True.'\n"
		"\n"
		"See also getConstant(), isSetConstant(), setConstant().\n"
		"\n"
		""},
	 { "Parameter_getId", _wrap_Parameter_getId, METH_O, "\n"
		"Parameter_getId(Parameter self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this Parameter.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() function instead.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this Parameter.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Parameter_getName", _wrap_Parameter_getName, METH_O, "\n"
		"Parameter_getName(Parameter self) -> string\n"
		"\n"
		"Returns the value of the 'name' attribute of this Parameter object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns the name of this SBML object, or the empty string if not set\n"
		"or unsettable.\n"
		"\n"
		"See also getIdAttribute(), isSetName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "Parameter_getValue", _wrap_Parameter_getValue, METH_O, "\n"
		"Parameter_getValue(Parameter self) -> double\n"
		"\n"
		"Returns the numerical value of this Parameter.\n"
		"\n"
		"Returns the value of the 'value' attribute of this Parameter, as a\n"
		"number of type 'float.'\n"
		"\n"
		"Note: It is crucial that callers not blindly call Parameter.getValue()\n"
		"without first using Parameter.isSetValue() to determine whether a\n"
		"value has ever been set.  Otherwise, the value return by\n"
		"Parameter.getValue() may not actually represent a value assigned to\n"
		"the parameter.  The reason is simply that the data type 'float' in a\n"
		"program always has some value.  A separate test is needed to determine\n"
		"whether the value is a true model value, or uninitialized data in a\n"
		"computer's memory location.\n"
		"\n"
		"See also isSetValue(), setValue(), getUnits().\n"
		"\n"
		""},
	 { "Parameter_getUnits", _wrap_Parameter_getUnits, METH_O, "\n"
		"Parameter_getUnits(Parameter self) -> string\n"
		"\n"
		"Returns the units defined for this Parameter.\n"
		"\n"
		"The value of an SBML parameter's 'units' attribute establishes the\n"
		"unit of measurement associated with the parameter's value.\n"
		"\n"
		"Returns the value of the 'units' attribute of this Parameter, as a\n"
		"string.  An empty string indicates that no units have been assigned.\n"
		"\n"
		"Note: There is an important distinction to be made between no units\n"
		"assigned, and assuming a value without units has any specific unit\n"
		"such as dimensionless.  In SBML, default units are never attributed to\n"
		"numbers, and numbers without units are not automatically assumed to\n"
		"have the unit dimensionless.  Please consult the relevant SBML\n"
		"specification document for a more in-depth explanation of this topic\n"
		"and the SBML unit system.\n"
		"\n"
		"See also isSetUnits(), setUnits(), getValue().\n"
		"\n"
		""},
	 { "Parameter_getConstant", _wrap_Parameter_getConstant, METH_O, "\n"
		"Parameter_getConstant(Parameter self) -> bool\n"
		"\n"
		"Returns the value of the 'constant' attribute of this Parameter\n"
		"instance.\n"
		"\n"
		"Returns 'True' if this Parameter is declared as being constant,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Readers who view the documentation for LocalParameter may be\n"
		"confused about the presence of this method.  LibSBML derives\n"
		"LocalParameter from Parameter; however, this does not precisely match\n"
		"the object hierarchy defined by SBML Level 3, where LocalParameter is\n"
		"derived directly from SBase and not Parameter.  We believe this\n"
		"arrangement makes it easier for libSBML users to program applications\n"
		"that work with both SBML Level 2 and SBML Level 3, but programmers\n"
		"should also keep in mind this difference exists.  A side-effect of\n"
		"libSBML's scheme is that certain methods on LocalParameter that are\n"
		"inherited from Parameter do not actually have relevance to\n"
		"LocalParameter objects.  An example of this is the methods pertaining\n"
		"to Parameter's attribute 'constant' (i.e., isSetConstant(),\n"
		"setConstant(), and getConstant()).\n"
		"\n"
		"See also isSetConstant(), setConstant().\n"
		"\n"
		""},
	 { "Parameter_isSetId", _wrap_Parameter_isSetId, METH_O, "\n"
		"Parameter_isSetId(Parameter self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Parameter's 'id' attribute is set.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is recommended that callers use\n"
		"isSetIdAttribute() instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),\n"
		"isSetIdAttribute().\n"
		"\n"
		""},
	 { "Parameter_isSetName", _wrap_Parameter_isSetName, METH_O, "\n"
		"Parameter_isSetName(Parameter self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Parameter's 'name' attribute is\n"
		"set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns 'True' if the 'name' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "Parameter_isSetValue", _wrap_Parameter_isSetValue, METH_O, "\n"
		"Parameter_isSetValue(Parameter self) -> bool\n"
		"\n"
		"Predicate returning 'True' if the 'value' attribute of this Parameter\n"
		"is set.\n"
		"\n"
		"In SBML definitions after SBML Level 1 Version 1, parameter values are\n"
		"optional and have no defaults.  If a model read from a file does not\n"
		"contain a setting for the 'value' attribute of a parameter, its value\n"
		"is considered unset; it does not default to any particular value.\n"
		"Similarly, when a Parameter object is created in libSBML, it has no\n"
		"value until given a value.  The Parameter.isSetValue() method allows\n"
		"calling applications to determine whether a given parameter's value\n"
		"has ever been set.\n"
		"\n"
		"In SBML Level 1 Version 1, parameters are required to have values and\n"
		"therefore, the value of a Parameter should always be set.  In Level 1\n"
		"Version 2 and beyond, the value is optional and as such, the 'value'\n"
		"attribute may or may not be set.\n"
		"\n"
		"Returns 'True' if the value of this Parameter is set, 'False'\n"
		"otherwise.\n"
		"\n"
		"See also getValue(), setValue().\n"
		"\n"
		""},
	 { "Parameter_isSetUnits", _wrap_Parameter_isSetUnits, METH_O, "\n"
		"Parameter_isSetUnits(Parameter self) -> bool\n"
		"\n"
		"Predicate returning 'True' if the 'units' attribute of this Parameter\n"
		"is set.\n"
		"\n"
		"Returns 'True' if the 'units' attribute of this Parameter is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: There is an important distinction to be made between no units\n"
		"assigned, and assuming a value without units has any specific unit\n"
		"such as dimensionless.  In SBML, default units are never attributed to\n"
		"numbers, and numbers without units are not automatically assumed to\n"
		"have the unit dimensionless.  Please consult the relevant SBML\n"
		"specification document for a more in-depth explanation of this topic\n"
		"and the SBML unit system.\n"
		"\n"
		""},
	 { "Parameter_isSetConstant", _wrap_Parameter_isSetConstant, METH_O, "\n"
		"Parameter_isSetConstant(Parameter self) -> bool\n"
		"\n"
		"Predicate returning 'True' if the 'constant' attribute of this\n"
		"Parameter is set.\n"
		"\n"
		"Returns 'True' if the 'constant' attribute of this Parameter is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Readers who view the documentation for LocalParameter may be\n"
		"confused about the presence of this method.  LibSBML derives\n"
		"LocalParameter from Parameter; however, this does not precisely match\n"
		"the object hierarchy defined by SBML Level 3, where LocalParameter is\n"
		"derived directly from SBase and not Parameter.  We believe this\n"
		"arrangement makes it easier for libSBML users to program applications\n"
		"that work with both SBML Level 2 and SBML Level 3, but programmers\n"
		"should also keep in mind this difference exists.  A side-effect of\n"
		"libSBML's scheme is that certain methods on LocalParameter that are\n"
		"inherited from Parameter do not actually have relevance to\n"
		"LocalParameter objects.  An example of this is the methods pertaining\n"
		"to Parameter's attribute 'constant' (i.e., isSetConstant(),\n"
		"setConstant(), and getConstant()).\n"
		"\n"
		"See also getConstant(), setConstant().\n"
		"\n"
		""},
	 { "Parameter_setId", _wrap_Parameter_setId, METH_VARARGS, "\n"
		"Parameter_setId(Parameter self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this Parameter.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Parameter_setName", _wrap_Parameter_setName, METH_VARARGS, "\n"
		"Parameter_setName(Parameter self, string name) -> int\n"
		"\n"
		"Sets the value of the 'name' attribute of this Parameter.\n"
		"\n"
		"The string in 'name' is copied.\n"
		"\n"
		"Parameter 'name' is the new name for the Parameter.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Parameter_setValue", _wrap_Parameter_setValue, METH_VARARGS, "\n"
		"Parameter_setValue(Parameter self, double value) -> int\n"
		"\n"
		"Sets the 'value' attribute of this Parameter to the given 'float'\n"
		"value and marks the attribute as set.\n"
		"\n"
		"Parameter 'value' is a 'float,' the value to assign.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "Parameter_setUnits", _wrap_Parameter_setUnits, METH_VARARGS, "\n"
		"Parameter_setUnits(Parameter self, string units) -> int\n"
		"\n"
		"Sets the 'units' attribute of this Parameter to a copy of the given\n"
		"units identifier 'units'.\n"
		"\n"
		"Parameter 'units' is a string, the identifier of the units to assign\n"
		"to this Parameter instance.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Parameter_setConstant", _wrap_Parameter_setConstant, METH_VARARGS, "\n"
		"Parameter_setConstant(Parameter self, bool flag) -> int\n"
		"\n"
		"Sets the 'constant' attribute of this Parameter to the given boolean\n"
		"'flag'.\n"
		"\n"
		"Parameter 'flag' is a boolean, the value for the 'constant' attribute\n"
		"of this Parameter instance.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: Readers who view the documentation for LocalParameter may be\n"
		"confused about the presence of this method.  LibSBML derives\n"
		"LocalParameter from Parameter; however, this does not precisely match\n"
		"the object hierarchy defined by SBML Level 3, where LocalParameter is\n"
		"derived directly from SBase and not Parameter.  We believe this\n"
		"arrangement makes it easier for libSBML users to program applications\n"
		"that work with both SBML Level 2 and SBML Level 3, but programmers\n"
		"should also keep in mind this difference exists.  A side-effect of\n"
		"libSBML's scheme is that certain methods on LocalParameter that are\n"
		"inherited from Parameter do not actually have relevance to\n"
		"LocalParameter objects.  An example of this is the methods pertaining\n"
		"to Parameter's attribute 'constant' (i.e., isSetConstant(),\n"
		"setConstant(), and getConstant()).\n"
		"\n"
		"See also getConstant(), isSetConstant().\n"
		"\n"
		""},
	 { "Parameter_unsetName", _wrap_Parameter_unsetName, METH_O, "\n"
		"Parameter_unsetName(Parameter self) -> int\n"
		"\n"
		"Unsets the value of the 'name' attribute of this Parameter.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getName(), setName(), isSetName().\n"
		"\n"
		""},
	 { "Parameter_unsetConstant", _wrap_Parameter_unsetConstant, METH_O, "\n"
		"Parameter_unsetConstant(Parameter self) -> int\n"
		"\n"
		"Unsets the value of the 'constant' attribute of this Parameter object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also isSetConstant(), setConstant(), getConstant().\n"
		"\n"
		""},
	 { "Parameter_unsetValue", _wrap_Parameter_unsetValue, METH_O, "\n"
		"Parameter_unsetValue(Parameter self) -> int\n"
		"\n"
		"Unsets the 'value' attribute of this Parameter instance.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"In SBML Level 1 Version 1, parameters are required to have values and\n"
		"therefore, the value of a Parameter should always be set.  In SBML\n"
		"Level 1 Version 2 and beyond, the value is optional and as such, the\n"
		"'value' attribute may or may not be set.\n"
		"\n"
		""},
	 { "Parameter_unsetUnits", _wrap_Parameter_unsetUnits, METH_O, "\n"
		"Parameter_unsetUnits(Parameter self) -> int\n"
		"\n"
		"Unsets the 'units' attribute of this Parameter instance.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Parameter_getDerivedUnitDefinition", _wrap_Parameter_getDerivedUnitDefinition, METH_VARARGS, "\n"
		"Parameter_getDerivedUnitDefinition(Parameter self) -> UnitDefinition\n"
		"Parameter_getDerivedUnitDefinition(Parameter self) -> UnitDefinition\n"
		"\n"
		"Constructs and returns a UnitDefinition that corresponds to the units\n"
		"of this Parameter's value.\n"
		"\n"
		"Parameters in SBML have an attribute ('units') for declaring the units\n"
		"of measurement intended for the parameter's value.  No defaults are\n"
		"defined by SBML in the absence of a definition for 'units'.  This\n"
		"method returns a UnitDefinition object based on the units declared for\n"
		"this Parameter using its 'units' attribute, or it returns 'None' if no\n"
		"units have been declared.\n"
		"\n"
		"Note that unit declarations for Parameter objects are specified in\n"
		"terms of the identifier of a unit (e.g., using setUnits()), but this\n"
		"method returns a UnitDefinition object, not a unit identifier.  It\n"
		"does this by constructing an appropriate UnitDefinition.For SBML Level\n"
		"2 models, it will do this even when the value of the 'units' attribute\n"
		"is one of the special SBML Level 2 unit identifiers ''substance','\n"
		"''volume',' ''area',' ''length'' or ''time'.'  Callers may find this\n"
		"useful in conjunction with the helper methods provided by the\n"
		"UnitDefinition class for comparing different UnitDefinition objects.\n"
		"\n"
		"Returns a UnitDefinition that expresses the units of this  Parameter,\n"
		"or 'None' if one cannot be constructed.\n"
		"\n"
		"Note: The libSBML system for unit analysis depends on the model as a\n"
		"whole.  In cases where the Parameter object has not yet been added to\n"
		"a model, or the model itself is incomplete, unit analysis is not\n"
		"possible, and consequently this method will return 'None.'\n"
		"\n"
		"See also isSetUnits().\n"
		"\n"
		""},
	 { "Parameter_getTypeCode", _wrap_Parameter_getTypeCode, METH_O, "\n"
		"Parameter_getTypeCode(Parameter self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_PARAMETER (default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "Parameter_getElementName", _wrap_Parameter_getElementName, METH_O, "\n"
		"Parameter_getElementName(Parameter self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for Parameter, is\n"
		"always ''parameter'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''parameter'.'\n"
		"\n"
		""},
	 { "Parameter_hasRequiredAttributes", _wrap_Parameter_hasRequiredAttributes, METH_O, "\n"
		"Parameter_hasRequiredAttributes(Parameter self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"Parameter object have been set.\n"
		"\n"
		"The required attributes for a Parameter object are:\n"
		"\n"
		"* 'id' (or 'name' in SBML Level 1)\n"
		"\n"
		"* 'value' (required in Level 1, optional otherwise)\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Parameter_renameUnitSIdRefs", _wrap_Parameter_renameUnitSIdRefs, METH_VARARGS, "\n"
		"Parameter_renameUnitSIdRefs(Parameter self, string oldid, string newid)\n"
		"\n"
		"Renames all the 'UnitSIdRef' attributes on this element.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the unit identifiers to the value of 'oldid'.  If any matches are\n"
		"found, the matching identifiers are replaced with 'newid'.  The method\n"
		"does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Parameter_setCalculatingUnits", _wrap_Parameter_setCalculatingUnits, METH_VARARGS, "\n"
		"Parameter_setCalculatingUnits(Parameter self, bool calculatingUnits)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Parameter_swigregister", Parameter_swigregister, METH_O, NULL},
	 { "Parameter_swiginit", Parameter_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfParameters", _wrap_new_ListOfParameters, METH_VARARGS, "\n"
		"ListOfParameters(unsigned int level, unsigned int version)\n"
		"new_ListOfParameters(SBMLNamespaces sbmlns) -> ListOfParameters\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfParameters(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfParameters object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfParameters object to be\n"
		"created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfParameters(long level, long version)\n"
		"\n"
		"Creates a new ListOfParameters object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfParameters_clone", _wrap_ListOfParameters_clone, METH_O, "\n"
		"ListOfParameters_clone(ListOfParameters self) -> ListOfParameters\n"
		"\n"
		"Creates and returns a deep copy of this ListOfParameters object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfParameters object.\n"
		"\n"
		""},
	 { "ListOfParameters_getItemTypeCode", _wrap_ListOfParameters_getItemTypeCode, METH_O, "\n"
		"ListOfParameters_getItemTypeCode(ListOfParameters self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., Parameter objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this objects contained in this list:\n"
		"SBML_PARAMETER (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfParameters_getElementName", _wrap_ListOfParameters_getElementName, METH_O, "\n"
		"ListOfParameters_getElementName(ListOfParameters self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfParameters, the XML element name is ''listOfParameters'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfParameters'.'\n"
		"\n"
		""},
	 { "ListOfParameters_get", _wrap_ListOfParameters_get, METH_VARARGS, "\n"
		"ListOfParameters_get(ListOfParameters self, unsigned int n) -> Parameter\n"
		"ListOfParameters_get(ListOfParameters self, unsigned int n) -> Parameter\n"
		"ListOfParameters_get(ListOfParameters self, string sid) -> Parameter\n"
		"ListOfParameters_get(ListOfParameters self, string sid) -> Parameter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Returns the Parameter object located at position 'n' within this\n"
		"ListOfParameters instance.\n"
		"\n"
		"Parameter 'n' is the index number of the Parameter to get.\n"
		"\n"
		"Returns the nth Parameter in this ListOfParameters.  If the index 'n'\n"
		"is out of bounds for the length of the list, then 'None' is returned.\n"
		"\n"
		"See also size(), get().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Returns the first Parameter object matching the given identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier of the\n"
		"Parameter to get.\n"
		"\n"
		"Returns the Parameter object found.  The caller owns the returned\n"
		"object and is responsible for deleting it.  If none of the items have\n"
		"an identifier matching 'sid', then 'None' is returned.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfParameters_remove", _wrap_ListOfParameters_remove, METH_VARARGS, "\n"
		"ListOfParameters_remove(ListOfParameters self, unsigned int n) -> Parameter\n"
		"ListOfParameters_remove(ListOfParameters self, string sid) -> Parameter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfParameters, and returns a pointer\n"
		"to it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"Returns the item removed.  The caller owns the returned object and is\n"
		"responsible for deleting it.  If the index number 'n' is out of bounds\n"
		"for the length of the list, then 'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes the first Parameter object in this ListOfParameters matching\n"
		"the given identifier, and returns a pointer to it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  The caller owns the returned object and is\n"
		"responsible for deleting it.  If none of the items have an identifier\n"
		"matching 'sid', then 'None' is returned.\n"
		"\n"
		""},
	 { "delete_ListOfParameters", _wrap_delete_ListOfParameters, METH_O, "delete_ListOfParameters(ListOfParameters self)"},
	 { "ListOfParameters_swigregister", ListOfParameters_swigregister, METH_O, NULL},
	 { "ListOfParameters_swiginit", ListOfParameters_swiginit, METH_VARARGS, NULL},
	 { "delete_LocalParameter", _wrap_delete_LocalParameter, METH_O, "delete_LocalParameter(LocalParameter self)"},
	 { "new_LocalParameter", _wrap_new_LocalParameter, METH_VARARGS, "\n"
		"LocalParameter(unsigned int level, unsigned int version)\n"
		"LocalParameter(SBMLNamespaces sbmlns)\n"
		"LocalParameter(LocalParameter orig)\n"
		"new_LocalParameter(Parameter orig) -> LocalParameter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    LocalParameter(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new LocalParameter object with the given SBMLNamespaces\n"
		"object 'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"It is worth emphasizing that although this constructor does not take\n"
		"an identifier argument, in SBML Level 2 and beyond, the 'id'\n"
		"(identifier) attribute of a LocalParameter is required to have a\n"
		"value. Thus, callers are cautioned to assign a value after calling\n"
		"this constructor if no identifier is provided as an argument.  Setting\n"
		"the identifier can be accomplished using the method setId().\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    LocalParameter(long level, long version)\n"
		"\n"
		"Creates a new LocalParameter object with the given SBML 'level' and\n"
		"'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"LocalParameter.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this LocalParameter.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    LocalParameter(LocalParameter orig)\n"
		"\n"
		"Copy constructor; creates a copy of a given LocalParameter object.\n"
		"\n"
		"Parameter 'orig' is the LocalParameter instance to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    LocalParameter(Parameter orig)\n"
		"\n"
		"Copy constructor; creates a LocalParameter object by copying the\n"
		"attributes of a given Parameter object.\n"
		"\n"
		"Parameter 'orig' is the Parameter instance to copy.\n"
		"\n"
		""},
	 { "LocalParameter_clone", _wrap_LocalParameter_clone, METH_O, "\n"
		"LocalParameter_clone(LocalParameter self) -> LocalParameter\n"
		"\n"
		"Creates and returns a deep copy of this LocalParameter object.\n"
		"\n"
		"Returns the (deep) copy of this LocalParameter object.\n"
		"\n"
		""},
	 { "LocalParameter_getDerivedUnitDefinition", _wrap_LocalParameter_getDerivedUnitDefinition, METH_VARARGS, "\n"
		"LocalParameter_getDerivedUnitDefinition(LocalParameter self) -> UnitDefinition\n"
		"LocalParameter_getDerivedUnitDefinition(LocalParameter self) -> UnitDefinition\n"
		"\n"
		"Constructs and returns a UnitDefinition that corresponds to the units\n"
		"of this LocalParameter's value.\n"
		"\n"
		"LocalParameters in SBML have an attribute ('units') for declaring the\n"
		"units of measurement intended for the parameter's value.  No defaults\n"
		"are defined by SBML in the absence of a definition for 'units'.  This\n"
		"method returns a UnitDefinition object based on the units declared for\n"
		"this LocalParameter using its 'units' attribute, or it returns 'None'\n"
		"if no units have been declared.\n"
		"\n"
		"Note that unit declarations for LocalParameter objects are specified\n"
		"in terms of the identifier of a unit (e.g., using setUnits()), but\n"
		"this method returns a UnitDefinition object, not a unit identifier.\n"
		"It does this by constructing an appropriate UnitDefinition.  For SBML\n"
		"Level 2 models, it will do this even when the value of the 'units'\n"
		"attribute is one of the predefined SBML units ''substance','\n"
		"''volume',' ''area',' ''length'' or ''time'.'  Callers may find this\n"
		"useful in conjunction with the helper methods provided by the\n"
		"UnitDefinition class for comparing different UnitDefinition objects.\n"
		"\n"
		"Returns a UnitDefinition that expresses the units of this\n"
		"LocalParameter, or 'None' if one cannot be constructed.\n"
		"\n"
		"Note: The libSBML system for unit analysis depends on the model as a\n"
		"whole.  In cases where the LocalParameter object has not yet been\n"
		"added to a model, or the model itself is incomplete, unit analysis is\n"
		"not possible, and consequently this method will return 'None.'\n"
		"\n"
		"See also isSetUnits().\n"
		"\n"
		""},
	 { "LocalParameter_getTypeCode", _wrap_LocalParameter_getTypeCode, METH_O, "\n"
		"LocalParameter_getTypeCode(LocalParameter self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_LOCAL_PARAMETER\n"
		"(default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "LocalParameter_getElementName", _wrap_LocalParameter_getElementName, METH_O, "\n"
		"LocalParameter_getElementName(LocalParameter self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for LocalParameter,\n"
		"is always ''localParameter'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''localParameter'.'\n"
		"\n"
		""},
	 { "LocalParameter_hasRequiredAttributes", _wrap_LocalParameter_hasRequiredAttributes, METH_O, "\n"
		"LocalParameter_hasRequiredAttributes(LocalParameter self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"LocalParameter object have been set.\n"
		"\n"
		"The required attributes for a LocalParameter object are:\n"
		"\n"
		"* 'id'\n"
		"\n"
		"* 'value'\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "LocalParameter_getConstant", _wrap_LocalParameter_getConstant, METH_O, "\n"
		"LocalParameter_getConstant(LocalParameter self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "LocalParameter_isSetConstant", _wrap_LocalParameter_isSetConstant, METH_O, "\n"
		"LocalParameter_isSetConstant(LocalParameter self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "LocalParameter_setConstant", _wrap_LocalParameter_setConstant, METH_VARARGS, "\n"
		"LocalParameter_setConstant(LocalParameter self, bool flag) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "LocalParameter_unsetConstant", _wrap_LocalParameter_unsetConstant, METH_O, "\n"
		"LocalParameter_unsetConstant(LocalParameter self) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "LocalParameter_swigregister", LocalParameter_swigregister, METH_O, NULL},
	 { "LocalParameter_swiginit", LocalParameter_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfLocalParameters", _wrap_new_ListOfLocalParameters, METH_VARARGS, "\n"
		"ListOfLocalParameters(unsigned int level, unsigned int version)\n"
		"new_ListOfLocalParameters(SBMLNamespaces sbmlns) -> ListOfLocalParameters\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfLocalParameters(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfLocalParameters object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfLocalParameters object to\n"
		"be created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfLocalParameters(long level, long version)\n"
		"\n"
		"Creates a new ListOfLocalParameters object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfLocalParameters_clone", _wrap_ListOfLocalParameters_clone, METH_O, "\n"
		"ListOfLocalParameters_clone(ListOfLocalParameters self) -> ListOfLocalParameters\n"
		"\n"
		"Creates and returns a deep copy of this ListOfLocalParameters object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfLocalParameters object.\n"
		"\n"
		""},
	 { "ListOfLocalParameters_getItemTypeCode", _wrap_ListOfLocalParameters_getItemTypeCode, METH_O, "\n"
		"ListOfLocalParameters_getItemTypeCode(ListOfLocalParameters self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., LocalParameter objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for the objects contained in this ListOf:\n"
		"SBML_LOCAL_PARAMETER (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfLocalParameters_getElementName", _wrap_ListOfLocalParameters_getElementName, METH_O, "\n"
		"ListOfLocalParameters_getElementName(ListOfLocalParameters self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfLocalParameters, the XML element name is\n"
		"''listOfLocalParameters'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfLocalParameters'.'\n"
		"\n"
		""},
	 { "ListOfLocalParameters_get", _wrap_ListOfLocalParameters_get, METH_VARARGS, "\n"
		"ListOfLocalParameters_get(ListOfLocalParameters self, unsigned int n) -> LocalParameter\n"
		"ListOfLocalParameters_get(ListOfLocalParameters self, unsigned int n) -> LocalParameter\n"
		"ListOfLocalParameters_get(ListOfLocalParameters self, string sid) -> LocalParameter\n"
		"ListOfLocalParameters_get(ListOfLocalParameters self, string sid) -> LocalParameter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Returns the LocalParameter object located at position 'n' within this\n"
		"ListOfLocalParameters instance.\n"
		"\n"
		"Parameter 'n' is the index number of the LocalParameter to get.\n"
		"\n"
		"Returns the item at position 'n'.  The caller owns the returned object\n"
		"and is responsible for deleting it.  If the index number 'n' is out of\n"
		"bounds for the length of the list, then 'None' is returned.\n"
		"\n"
		"See also size(), get().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Returns the first LocalParameter object matching the given identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier of the\n"
		"LocalParameter to get.\n"
		"\n"
		"Returns the LocalParameter object found.  The caller owns the returned\n"
		"object and is responsible for deleting it.  If none of the items have\n"
		"an identifier matching 'sid', then 'None' is returned.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfLocalParameters_getElementBySId", _wrap_ListOfLocalParameters_getElementBySId, METH_VARARGS, "\n"
		"ListOfLocalParameters_getElementBySId(ListOfLocalParameters self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given 'id' in the\n"
		"model-wide SId namespace, or 'None' if no such object is found.\n"
		"\n"
		"Note that LocalParameters, while they use the SId namespace, are not\n"
		"in the model-wide SId namespace, so no LocalParameter object will be\n"
		"returned from this function (and is the reason we override the base\n"
		"ListOf::getElementBySId function here).\n"
		"\n"
		"Parameter 'id' is string representing the id of the object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'id'.\n"
		"\n"
		""},
	 { "ListOfLocalParameters_remove", _wrap_ListOfLocalParameters_remove, METH_VARARGS, "\n"
		"ListOfLocalParameters_remove(ListOfLocalParameters self, unsigned int n) -> LocalParameter\n"
		"ListOfLocalParameters_remove(ListOfLocalParameters self, string sid) -> LocalParameter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfLocalParameters, and returns a\n"
		"pointer to it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"Returns the item removed.  The caller owns the returned object and is\n"
		"responsible for deleting it.  If the index number 'n' is out of bounds\n"
		"for the length of the list, then 'None' is returned.\n"
		"\n"
		"See also size(), remove().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes the first LocalParameter object in this ListOfLocalParameters\n"
		"matching the given identifier, and returns a pointer to it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  The caller owns the returned object and is\n"
		"responsible for deleting it.  If none of the items have an identifier\n"
		"matching 'sid', then 'None' is returned.\n"
		"\n"
		""},
	 { "delete_ListOfLocalParameters", _wrap_delete_ListOfLocalParameters, METH_O, "delete_ListOfLocalParameters(ListOfLocalParameters self)"},
	 { "ListOfLocalParameters_swigregister", ListOfLocalParameters_swigregister, METH_O, NULL},
	 { "ListOfLocalParameters_swiginit", ListOfLocalParameters_swiginit, METH_VARARGS, NULL},
	 { "delete_InitialAssignment", _wrap_delete_InitialAssignment, METH_O, "delete_InitialAssignment(InitialAssignment self)"},
	 { "new_InitialAssignment", _wrap_new_InitialAssignment, METH_VARARGS, "\n"
		"InitialAssignment(unsigned int level, unsigned int version)\n"
		"InitialAssignment(SBMLNamespaces sbmlns)\n"
		"new_InitialAssignment(InitialAssignment orig) -> InitialAssignment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    InitialAssignment(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new InitialAssignment using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    InitialAssignment(long level, long version)\n"
		"\n"
		"Creates a new InitialAssignment using the given SBML 'level' and\n"
		"'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"InitialAssignment.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this InitialAssignment.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    InitialAssignment(InitialAssignment orig)\n"
		"\n"
		"Copy constructor; creates a copy of this InitialAssignment.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "InitialAssignment_clone", _wrap_InitialAssignment_clone, METH_O, "\n"
		"InitialAssignment_clone(InitialAssignment self) -> InitialAssignment\n"
		"\n"
		"Creates and returns a deep copy of this InitialAssignment object.\n"
		"\n"
		"Returns the (deep) copy of this InitialAssignment object.\n"
		"\n"
		""},
	 { "InitialAssignment_getSymbol", _wrap_InitialAssignment_getSymbol, METH_O, "\n"
		"InitialAssignment_getSymbol(InitialAssignment self) -> string\n"
		"\n"
		"Get the value of the 'symbol' attribute of this InitialAssignment.\n"
		"\n"
		"Returns the identifier string stored as the 'symbol' attribute value\n"
		"in this InitialAssignment.\n"
		"\n"
		""},
	 { "InitialAssignment_getMath", _wrap_InitialAssignment_getMath, METH_O, "\n"
		"InitialAssignment_getMath(InitialAssignment self) -> ASTNode\n"
		"\n"
		"Get the mathematical formula of this InitialAssignment.\n"
		"\n"
		"Returns an ASTNode, the value of the 'math' subelement of this\n"
		"InitialAssignment, or 'None' if the math is not set.\n"
		"\n"
		""},
	 { "InitialAssignment_isSetSymbol", _wrap_InitialAssignment_isSetSymbol, METH_O, "\n"
		"InitialAssignment_isSetSymbol(InitialAssignment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this InitialAssignment's 'symbol'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'symbol' attribute of this InitialAssignment is\n"
		"set, 'False' otherwise.\n"
		"\n"
		""},
	 { "InitialAssignment_isSetMath", _wrap_InitialAssignment_isSetMath, METH_O, "\n"
		"InitialAssignment_isSetMath(InitialAssignment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this InitialAssignment's 'math'\n"
		"subelement contains a value.\n"
		"\n"
		"Returns 'True' if the 'math' for this InitialAssignment is set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "InitialAssignment_setSymbol", _wrap_InitialAssignment_setSymbol, METH_VARARGS, "\n"
		"InitialAssignment_setSymbol(InitialAssignment self, string sid) -> int\n"
		"\n"
		"Sets the 'symbol' attribute value of this InitialAssignment.\n"
		"\n"
		"Parameter 'sid' is the identifier of an element defined in this model\n"
		"whose value can be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "InitialAssignment_unsetSymbol", _wrap_InitialAssignment_unsetSymbol, METH_O, "\n"
		"InitialAssignment_unsetSymbol(InitialAssignment self) -> int\n"
		"\n"
		"Unsets the 'symbol' attribute value of this InitialAssignment.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "InitialAssignment_setMath", _wrap_InitialAssignment_setMath, METH_VARARGS, "\n"
		"InitialAssignment_setMath(InitialAssignment self, ASTNode math) -> int\n"
		"\n"
		"Sets the 'math' subelement of this InitialAssignment.\n"
		"\n"
		"The AST passed in 'math' is copied.\n"
		"\n"
		"Parameter 'math' is an AST containing the mathematical expression to\n"
		"be used as the formula for this InitialAssignment.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "InitialAssignment_getDerivedUnitDefinition", _wrap_InitialAssignment_getDerivedUnitDefinition, METH_VARARGS, "\n"
		"InitialAssignment_getDerivedUnitDefinition(InitialAssignment self) -> UnitDefinition\n"
		"InitialAssignment_getDerivedUnitDefinition(InitialAssignment self) -> UnitDefinition\n"
		"\n"
		"Calculates and returns a UnitDefinition that expresses the units of\n"
		"measurement assumed for the 'math' expression of this\n"
		"InitialAssignment.\n"
		"\n"
		"The units are calculated based on the mathematical expression in the\n"
		"InitialAssignment and the model quantities referenced by <ci> elements\n"
		"used within that expression.  The method\n"
		"InitialAssignment.getDerivedUnitDefinition() returns the calculated\n"
		"units, to the extent that libSBML can compute them.\n"
		"\n"
		"Note: The functionality that facilitates unit analysis depends on the\n"
		"model as a whole.  Thus, in cases where the object has not been added\n"
		"to a model or the model itself is incomplete, unit analysis is not\n"
		"possible and this method will return 'None.'\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Note that it is possible the 'math' expression in the\n"
		"InitialAssignment contains literal numbers or parameters with\n"
		"undeclared units.  In those cases, it is not possible to calculate the\n"
		"units of the overall expression without making assumptions.  LibSBML\n"
		"does not make assumptions about the units, and\n"
		"InitialAssignment.getDerivedUnitDefinition() only returns the units as\n"
		"far as it is able to determine them.  For example, in an expression X\n"
		"+ Y, if X has unambiguously-defined units and Y does not, it will\n"
		"return the units of X.  When using this method, it is critical that\n"
		"callers also invoke the method\n"
		"InitialAssignment.containsUndeclaredUnits() to determine whether this\n"
		"situation holds.  Callers should take suitable action in those\n"
		"situations.\n"
		"\n"
		"Returns a UnitDefinition that expresses the units of the math\n"
		"expression of this InitialAssignment, or 'None' if one cannot be\n"
		"constructed.\n"
		"\n"
		"See also containsUndeclaredUnits().\n"
		"\n"
		""},
	 { "InitialAssignment_containsUndeclaredUnits", _wrap_InitialAssignment_containsUndeclaredUnits, METH_VARARGS, "\n"
		"InitialAssignment_containsUndeclaredUnits(InitialAssignment self) -> bool\n"
		"InitialAssignment_containsUndeclaredUnits(InitialAssignment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if the math expression of this\n"
		"InitialAssignment contains parameters/numbers with undeclared units.\n"
		"\n"
		"Returns 'True' if the math expression of this InitialAssignment\n"
		"includes parameters/numbers  with undeclared units, 'False' otherwise.\n"
		"\n"
		"Note: A return value of 'True' indicates that the UnitDefinition\n"
		"returned by InitialAssignment::getDerivedUnitDefinition may not\n"
		"accurately represent the units of the expression.\n"
		"\n"
		"See also getDerivedUnitDefinition().\n"
		"\n"
		""},
	 { "InitialAssignment_getTypeCode", _wrap_InitialAssignment_getTypeCode, METH_O, "\n"
		"InitialAssignment_getTypeCode(InitialAssignment self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_INITIAL_ASSIGNMENT\n"
		"(default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "InitialAssignment_getElementName", _wrap_InitialAssignment_getElementName, METH_O, "\n"
		"InitialAssignment_getElementName(InitialAssignment self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for\n"
		"InitialAssignment, is always ''initialAssignment'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''initialAssignment'.'\n"
		"\n"
		""},
	 { "InitialAssignment_hasRequiredAttributes", _wrap_InitialAssignment_hasRequiredAttributes, METH_O, "\n"
		"InitialAssignment_hasRequiredAttributes(InitialAssignment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"InitialAssignment object have been set.\n"
		"\n"
		"The required attributes for an InitialAssignment object are:\n"
		"\n"
		"* 'symbol'\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "InitialAssignment_hasRequiredElements", _wrap_InitialAssignment_hasRequiredElements, METH_O, "\n"
		"InitialAssignment_hasRequiredElements(InitialAssignment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this\n"
		"InitialAssignment object have been set.\n"
		"\n"
		"Note: The required elements for a InitialAssignment object are:\n"
		"\n"
		"* 'math' inSBML Level 2 and Level 3 Version 1.   (In SBML Level 3\n"
		"Version 2+, it is no longer required.)\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "InitialAssignment_getId", _wrap_InitialAssignment_getId, METH_O, "\n"
		"InitialAssignment_getId(InitialAssignment self) -> string\n"
		"\n"
		"Returns the value of the 'symbol' attribute of this InitialAssignment\n"
		"(NOT the 'id').\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() or InitialAssignment.getSymbol()  functions instead.\n"
		"\n"
		"The 'symbol' attribute of an InitialAssignment indicates the element\n"
		"which the results of the 'math' are to be applied.\n"
		"\n"
		"Returns the symbol of this InitialAssignment.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute(), getSymbol().\n"
		"\n"
		""},
	 { "InitialAssignment_renameSIdRefs", _wrap_InitialAssignment_renameSIdRefs, METH_VARARGS, "\n"
		"InitialAssignment_renameSIdRefs(InitialAssignment self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "InitialAssignment_renameUnitSIdRefs", _wrap_InitialAssignment_renameUnitSIdRefs, METH_VARARGS, "\n"
		"InitialAssignment_renameUnitSIdRefs(InitialAssignment self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "InitialAssignment_replaceSIDWithFunction", _wrap_InitialAssignment_replaceSIDWithFunction, METH_VARARGS, "\n"
		"InitialAssignment_replaceSIDWithFunction(InitialAssignment self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "InitialAssignment_divideAssignmentsToSIdByFunction", _wrap_InitialAssignment_divideAssignmentsToSIdByFunction, METH_VARARGS, "\n"
		"InitialAssignment_divideAssignmentsToSIdByFunction(InitialAssignment self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "InitialAssignment_multiplyAssignmentsToSIdByFunction", _wrap_InitialAssignment_multiplyAssignmentsToSIdByFunction, METH_VARARGS, "\n"
		"InitialAssignment_multiplyAssignmentsToSIdByFunction(InitialAssignment self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "InitialAssignment_swigregister", InitialAssignment_swigregister, METH_O, NULL},
	 { "InitialAssignment_swiginit", InitialAssignment_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfInitialAssignments", _wrap_new_ListOfInitialAssignments, METH_VARARGS, "\n"
		"ListOfInitialAssignments(unsigned int level, unsigned int version)\n"
		"new_ListOfInitialAssignments(SBMLNamespaces sbmlns) -> ListOfInitialAssignments\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfInitialAssignments(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfInitialAssignments object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfInitialAssignments object\n"
		"to be created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfInitialAssignments(long level, long version)\n"
		"\n"
		"Creates a new ListOfInitialAssignments object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfInitialAssignments_clone", _wrap_ListOfInitialAssignments_clone, METH_O, "\n"
		"ListOfInitialAssignments_clone(ListOfInitialAssignments self) -> ListOfInitialAssignments\n"
		"\n"
		"Creates and returns a deep copy of this ListOfInitialAssignments\n"
		"object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfInitialAssignments object.\n"
		"\n"
		""},
	 { "ListOfInitialAssignments_getItemTypeCode", _wrap_ListOfInitialAssignments_getItemTypeCode, METH_O, "\n"
		"ListOfInitialAssignments_getItemTypeCode(ListOfInitialAssignments self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., InitialAssignment objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for the objects contained in this ListOf:\n"
		"SBML_INITIAL_ASSIGNMENT (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfInitialAssignments_getElementName", _wrap_ListOfInitialAssignments_getElementName, METH_O, "\n"
		"ListOfInitialAssignments_getElementName(ListOfInitialAssignments self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfInitialAssignments, the XML element name is\n"
		"''listOfInitialAssignments'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfInitialAssignments'.'\n"
		"\n"
		""},
	 { "ListOfInitialAssignments_get", _wrap_ListOfInitialAssignments_get, METH_VARARGS, "\n"
		"ListOfInitialAssignments_get(ListOfInitialAssignments self, unsigned int n) -> InitialAssignment\n"
		"ListOfInitialAssignments_get(ListOfInitialAssignments self, unsigned int n) -> InitialAssignment\n"
		"ListOfInitialAssignments_get(ListOfInitialAssignments self, string sid) -> InitialAssignment\n"
		"ListOfInitialAssignments_get(ListOfInitialAssignments self, string sid) -> InitialAssignment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Get a InitialAssignment from the ListOfInitialAssignments.\n"
		"\n"
		"Parameter 'n' is the index number of the InitialAssignment to get.\n"
		"\n"
		"Returns the nth InitialAssignment in this ListOfInitialAssignments. If\n"
		"the index 'n' is invalid, 'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Get a InitialAssignment from the ListOfInitialAssignments based on its\n"
		"identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier  of the\n"
		"InitialAssignment to get.\n"
		"\n"
		"Returns InitialAssignment in this ListOfInitialAssignments with the\n"
		"given 'sid' or 'None' if no such InitialAssignment exists.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfInitialAssignments_remove", _wrap_ListOfInitialAssignments_remove, METH_VARARGS, "\n"
		"ListOfInitialAssignments_remove(ListOfInitialAssignments self, unsigned int n) -> InitialAssignment\n"
		"ListOfInitialAssignments_remove(ListOfInitialAssignments self, string sid) -> InitialAssignment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfInitialAssignments items and\n"
		"returns a pointer to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes item in this ListOfInitialAssignments items with the given\n"
		"identifier.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"If none of the items in this list have the identifier 'sid', then\n"
		"'None' is returned.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  As mentioned above, the caller owns the\n"
		"returned item.\n"
		"\n"
		""},
	 { "ListOfInitialAssignments_getElementBySId", _wrap_ListOfInitialAssignments_getElementBySId, METH_VARARGS, "\n"
		"ListOfInitialAssignments_getElementBySId(ListOfInitialAssignments self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given 'id' in the\n"
		"model-wide SId namespace, or 'None' if no such object is found.\n"
		"\n"
		"Note that InitialAssignments do not actually have IDs, though the\n"
		"libsbml interface pretends that they do: no initial assignment is\n"
		"returned by this function.\n"
		"\n"
		"Parameter 'id' is string representing the id of the object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'id'.\n"
		"\n"
		""},
	 { "delete_ListOfInitialAssignments", _wrap_delete_ListOfInitialAssignments, METH_O, "delete_ListOfInitialAssignments(ListOfInitialAssignments self)"},
	 { "ListOfInitialAssignments_swigregister", ListOfInitialAssignments_swigregister, METH_O, NULL},
	 { "ListOfInitialAssignments_swiginit", ListOfInitialAssignments_swiginit, METH_VARARGS, NULL},
	 { "delete_Rule", _wrap_delete_Rule, METH_O, "delete_Rule(Rule self)"},
	 { "new_Rule", _wrap_new_Rule, METH_O, "\n"
		"new_Rule(Rule orig) -> Rule\n"
		"\n"
		"@internal\n"
		"\n"
		""},
	 { "Rule_clone", _wrap_Rule_clone, METH_O, "\n"
		"Rule_clone(Rule self) -> Rule\n"
		"\n"
		"Creates and returns a deep copy of this Rule object.\n"
		"\n"
		"Returns the (deep) copy of this Rule object.\n"
		"\n"
		""},
	 { "Rule_getFormula", _wrap_Rule_getFormula, METH_O, "\n"
		"Rule_getFormula(Rule self) -> string\n"
		"\n"
		"Returns the mathematical expression of this Rule in text-string form.\n"
		"\n"
		"The text string is produced by formulaToString(); please consult the\n"
		"documentation for that function to find out more about the format of\n"
		"the text-string formula.\n"
		"\n"
		"Returns the formula text string for this Rule.\n"
		"\n"
		"Note: The attribute 'formula' is specific to SBML Level 1; in higher\n"
		"Levels of SBML, it has been replaced with a subelement named 'math'.\n"
		"However, libSBML provides a unified interface to the underlying math\n"
		"expression and this method can be used for models of all Levels of\n"
		"SBML.\n"
		"\n"
		"See also getMath(), formulaToL3String().\n"
		"\n"
		""},
	 { "Rule_getMath", _wrap_Rule_getMath, METH_O, "\n"
		"Rule_getMath(Rule self) -> ASTNode\n"
		"\n"
		"Get the mathematical formula of this Rule as an ASTNode tree.\n"
		"\n"
		"Returns an ASTNode, the value of the 'math' subelement of this Rule,\n"
		"or 'None' if the math is not set.\n"
		"\n"
		"Note: The subelement 'math' is present in SBML Levels 2 and 3.  In\n"
		"SBML Level 1, the equivalent construct is the attribute named\n"
		"'formula'.  LibSBML provides a unified interface to the underlying\n"
		"math expression and this method can be used for models of all Levels\n"
		"of SBML.\n"
		"\n"
		"See also getFormula().\n"
		"\n"
		""},
	 { "Rule_getVariable", _wrap_Rule_getVariable, METH_O, "\n"
		"Rule_getVariable(Rule self) -> string\n"
		"\n"
		"Get the value of the 'variable' attribute of this Rule object.\n"
		"\n"
		"In SBML Level 1, the different rule types each have a different name\n"
		"for the attribute holding the reference to the object constituting the\n"
		"left-hand side of the rule.  (E.g., for SBML Level 1's\n"
		"SpeciesConcentrationRule the attribute is 'species', for\n"
		"CompartmentVolumeRule it is 'compartment', etc.)  In SBML Levels 2 and\n"
		"3, the only two types of Rule objects with a left-hand side object\n"
		"reference are AssignmentRule and RateRule, and both of them use the\n"
		"same name for attribute: 'variable'.  In order to make it easier for\n"
		"application developers to work with all Levels of SBML, libSBML uses a\n"
		"uniform name for all such attributes, and it is 'variable', regardless\n"
		"of whether Level 1 rules or Level 2-3 rules are being used.\n"
		"\n"
		"The 'variable' attribute of a Rule indicates the element which the\n"
		"results of the 'math' are to be applied.  An AlgebraicRule has no\n"
		"'variable', and will always return an empty string.\n"
		"\n"
		"Returns the identifier string stored as the 'variable' attribute value\n"
		"in this Rule, or 'None' if this object is an AlgebraicRule object, or\n"
		"if  the attribute is unset.\n"
		"\n"
		""},
	 { "Rule_getUnits", _wrap_Rule_getUnits, METH_O, "\n"
		"Rule_getUnits(Rule self) -> string\n"
		"\n"
		"Returns the units for the mathematical formula of this Rule.\n"
		"\n"
		"Returns the identifier of the units for the expression of this Rule.\n"
		"\n"
		"Note: The attribute 'units' exists on SBML Level 1 ParameterRule\n"
		"objects only.  It is not present in SBML Levels 2 and 3.\n"
		"\n"
		""},
	 { "Rule_isSetFormula", _wrap_Rule_isSetFormula, METH_O, "\n"
		"Rule_isSetFormula(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Rule's mathematical expression is\n"
		"set.\n"
		"\n"
		"This method is equivalent to isSetMath().  This version is present for\n"
		"easier compatibility with SBML Level 1, in which mathematical formulas\n"
		"were written in text-string form.\n"
		"\n"
		"Returns 'True' if the mathematical formula for this Rule is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The attribute 'formula' is specific to SBML Level 1; in higher\n"
		"Levels of SBML, it has been replaced with a subelement named 'math'.\n"
		"However, libSBML provides a unified interface to the underlying math\n"
		"expression and this method can be used for models of all Levels of\n"
		"SBML.\n"
		"\n"
		"See also isSetMath().\n"
		"\n"
		""},
	 { "Rule_isSetMath", _wrap_Rule_isSetMath, METH_O, "\n"
		"Rule_isSetMath(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Rule's mathematical expression is\n"
		"set.\n"
		"\n"
		"This method is equivalent to isSetFormula().\n"
		"\n"
		"Returns 'True' if the formula (or equivalently the math) for this Rule\n"
		"is set, 'False' otherwise.\n"
		"\n"
		"Note: The subelement 'math' is present in SBML Levels 2 and 3.  In\n"
		"SBML Level 1, the equivalent construct is the attribute named\n"
		"'formula'.  LibSBML provides a unified interface to the underlying\n"
		"math expression and this method can be used for models of all Levels\n"
		"of SBML.\n"
		"\n"
		"See also isSetFormula().\n"
		"\n"
		""},
	 { "Rule_isSetVariable", _wrap_Rule_isSetVariable, METH_O, "\n"
		"Rule_isSetVariable(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Rule's 'variable' attribute is set.\n"
		"\n"
		"In SBML Level 1, the different rule types each have a different name\n"
		"for the attribute holding the reference to the object constituting the\n"
		"left-hand side of the rule.  (E.g., for SBML Level 1's\n"
		"SpeciesConcentrationRule the attribute is 'species', for\n"
		"CompartmentVolumeRule it is 'compartment', etc.)  In SBML Levels 2 and\n"
		"3, the only two types of Rule objects with a left-hand side object\n"
		"reference are AssignmentRule and RateRule, and both of them use the\n"
		"same name for attribute: 'variable'.  In order to make it easier for\n"
		"application developers to work with all Levels of SBML, libSBML uses a\n"
		"uniform name for all such attributes, and it is 'variable', regardless\n"
		"of whether Level 1 rules or Level 2-3 rules are being used.\n"
		"\n"
		"Returns 'True' if the 'variable' attribute value of this Rule is set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "Rule_isSetUnits", _wrap_Rule_isSetUnits, METH_O, "\n"
		"Rule_isSetUnits(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Rule's 'units' attribute is set.\n"
		"\n"
		"Returns 'True' if the units for this Rule is set, 'False' otherwise.\n"
		"\n"
		"Note: The attribute 'units' exists on SBML Level 1 ParameterRule\n"
		"objects only.  It is not present in SBML Levels 2 and 3.\n"
		"\n"
		""},
	 { "Rule_setFormula", _wrap_Rule_setFormula, METH_VARARGS, "\n"
		"Rule_setFormula(Rule self, string formula) -> int\n"
		"\n"
		"Sets the 'math' subelement of this Rule to an expression in text-\n"
		"string form.\n"
		"\n"
		"This is equivalent to setMath(ASTNode math).  The provision of using\n"
		"text-string formulas is retained for easier SBML Level 1\n"
		"compatibility.  The formula is converted to an ASTNode internally.\n"
		"\n"
		"Parameter 'formula' is a mathematical formula in text-string form.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"Note: The attribute 'formula' is specific to SBML Level 1; in higher\n"
		"Levels of SBML, it has been replaced with a subelement named 'math'.\n"
		"However, libSBML provides a unified interface to the underlying math\n"
		"expression and this method can be used for models of all Levels of\n"
		"SBML.\n"
		"\n"
		"See also setMath().\n"
		"\n"
		""},
	 { "Rule_setMath", _wrap_Rule_setMath, METH_VARARGS, "\n"
		"Rule_setMath(Rule self, ASTNode math) -> int\n"
		"\n"
		"Sets the 'math' subelement of this Rule to a copy of the given\n"
		"ASTNode.\n"
		"\n"
		"Parameter 'math' is the AST structure of the mathematical formula.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"Note: The subelement 'math' is present in SBML Levels 2 and 3.  In\n"
		"SBML Level 1, the equivalent construct is the attribute named\n"
		"'formula'.  LibSBML provides a unified interface to the underlying\n"
		"math expression and this method can be used for models of all Levels\n"
		"of SBML.\n"
		"\n"
		"See also setFormula().\n"
		"\n"
		""},
	 { "Rule_setVariable", _wrap_Rule_setVariable, METH_VARARGS, "\n"
		"Rule_setVariable(Rule self, string sid) -> int\n"
		"\n"
		"Sets the 'variable' attribute value of this Rule object.\n"
		"\n"
		"In SBML Level 1, the different rule types each have a different name\n"
		"for the attribute holding the reference to the object constituting the\n"
		"left-hand side of the rule.  (E.g., for SBML Level 1's\n"
		"SpeciesConcentrationRule the attribute is 'species', for\n"
		"CompartmentVolumeRule it is 'compartment', etc.)  In SBML Levels 2 and\n"
		"3, the only two types of Rule objects with a left-hand side object\n"
		"reference are AssignmentRule and RateRule, and both of them use the\n"
		"same name for attribute: 'variable'.  In order to make it easier for\n"
		"application developers to work with all Levels of SBML, libSBML uses a\n"
		"uniform name for all such attributes, and it is 'variable', regardless\n"
		"of whether Level 1 rules or Level 2-3 rules are being used.\n"
		"\n"
		"Parameter 'sid' is the identifier of a Compartment, Species or\n"
		"Parameter elsewhere in the enclosing Model object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		""},
	 { "Rule_setUnits", _wrap_Rule_setUnits, METH_VARARGS, "\n"
		"Rule_setUnits(Rule self, string sname) -> int\n"
		"\n"
		"Sets the units for this Rule.\n"
		"\n"
		"Parameter 'sname' is the identifier of the units.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The attribute 'units' exists on SBML Level 1 ParameterRule\n"
		"objects only.  It is not present in SBML Levels 2 and 3.\n"
		"\n"
		""},
	 { "Rule_unsetVariable", _wrap_Rule_unsetVariable, METH_O, "\n"
		"Rule_unsetVariable(Rule self) -> int\n"
		"\n"
		"Unsets the value of the 'variable' attribute of this Rule object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also setVariable(), isSetVariable(), getVariable().\n"
		"\n"
		""},
	 { "Rule_unsetUnits", _wrap_Rule_unsetUnits, METH_O, "\n"
		"Rule_unsetUnits(Rule self) -> int\n"
		"\n"
		"Unsets the 'units' for this Rule.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The attribute 'units' exists on SBML Level 1 ParameterRule\n"
		"objects only.  It is not present in SBML Levels 2 and 3.\n"
		"\n"
		""},
	 { "Rule_getDerivedUnitDefinition", _wrap_Rule_getDerivedUnitDefinition, METH_VARARGS, "\n"
		"Rule_getDerivedUnitDefinition(Rule self) -> UnitDefinition\n"
		"Rule_getDerivedUnitDefinition(Rule self) -> UnitDefinition\n"
		"\n"
		"Calculates and returns a UnitDefinition that expresses the units of\n"
		"measurement assumed for the 'math' expression of this Rule.\n"
		"\n"
		"The units are calculated based on the mathematical expression in the\n"
		"Rule and the model quantities referenced by <ci> elements used within\n"
		"that expression.  The method Rule.getDerivedUnitDefinition() returns\n"
		"the calculated units, to the extent that libSBML can compute them.\n"
		"\n"
		"Note: The functionality that facilitates unit analysis depends on the\n"
		"model as a whole.  Thus, in cases where the object has not been added\n"
		"to a model or the model itself is incomplete, unit analysis is not\n"
		"possible and this method will return 'None.'\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Note that it is possible the 'math' expression in the Rule contains\n"
		"pure numbers or parameters with undeclared units.  In those cases, it\n"
		"is not possible to calculate the units of the overall expression\n"
		"without making assumptions.  LibSBML does not make assumptions about\n"
		"the units, and Rule.getDerivedUnitDefinition() only returns the units\n"
		"as far as it is able to determine them.  For example, in an expression\n"
		"X + Y, if X has unambiguously-defined units and Y does not, it will\n"
		"return the units of X. It is important that callers also invoke the\n"
		"method Rule.containsUndeclaredUnits() to determine whether this\n"
		"situation holds.  Callers may wish to take suitable actions in those\n"
		"scenarios.\n"
		"\n"
		"Returns a UnitDefinition that expresses the units of the math\n"
		"expression of this Rule, or 'None' if one cannot be constructed.\n"
		"\n"
		"See also containsUndeclaredUnits().\n"
		"\n"
		""},
	 { "Rule_containsUndeclaredUnits", _wrap_Rule_containsUndeclaredUnits, METH_VARARGS, "\n"
		"Rule_containsUndeclaredUnits(Rule self) -> bool\n"
		"Rule_containsUndeclaredUnits(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if the math expression of this Rule\n"
		"contains parameters/numbers with undeclared units.\n"
		"\n"
		"Returns 'True' if the math expression of this Rule includes\n"
		"parameters/numbers with undeclared units, 'False' otherwise.\n"
		"\n"
		"Note: A return value of 'True' indicates that the UnitDefinition\n"
		"returned by getDerivedUnitDefinition() may not accurately represent\n"
		"the units of the expression.\n"
		"\n"
		"See also getDerivedUnitDefinition().\n"
		"\n"
		""},
	 { "Rule_getType", _wrap_Rule_getType, METH_O, "\n"
		"Rule_getType(Rule self) -> RuleType_t\n"
		"\n"
		"Returns a code representing the type of rule this is.\n"
		"\n"
		"Returns the rule type, which will be one of the following three\n"
		"possible values:\n"
		"\n"
		"* RULE_TYPE_RATE\n"
		"\n"
		"* RULE_TYPE_SCALAR\n"
		"\n"
		"* RULE_TYPE_INVALID\n"
		"\n"
		"Note: The attribute 'type' on Rule objects is present only in SBML\n"
		"Level 1.  In SBML Level 2 and later, the type has been replaced by\n"
		"subclassing the Rule object.\n"
		"\n"
		""},
	 { "Rule_isAlgebraic", _wrap_Rule_isAlgebraic, METH_O, "\n"
		"Rule_isAlgebraic(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Rule is an AlgebraicRule.\n"
		"\n"
		"Returns 'True' if this Rule is an AlgebraicRule, 'False' otherwise.\n"
		"\n"
		""},
	 { "Rule_isAssignment", _wrap_Rule_isAssignment, METH_O, "\n"
		"Rule_isAssignment(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Rule is an AssignmentRule.\n"
		"\n"
		"Returns 'True' if this Rule is an AssignmentRule, 'False' otherwise.\n"
		"\n"
		""},
	 { "Rule_isCompartmentVolume", _wrap_Rule_isCompartmentVolume, METH_O, "\n"
		"Rule_isCompartmentVolume(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Rule is an CompartmentVolumeRule or\n"
		"equivalent.\n"
		"\n"
		"This libSBML method works for SBML Level 1 models (where there is such\n"
		"a thing as an explicit CompartmentVolumeRule), as well as other Levels\n"
		"of SBML.  For Levels above Level 1, this method checks the symbol\n"
		"being affected by the rule, and returns 'True' if the symbol is the\n"
		"identifier of a Compartment object defined in the model.\n"
		"\n"
		"Returns 'True' if this Rule is a CompartmentVolumeRule, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Rule_isParameter", _wrap_Rule_isParameter, METH_O, "\n"
		"Rule_isParameter(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Rule is an ParameterRule or\n"
		"equivalent.\n"
		"\n"
		"This libSBML method works for SBML Level 1 models (where there is such\n"
		"a thing as an explicit ParameterRule), as well as other Levels of\n"
		"SBML.  For Levels above Level 1, this method checks the symbol being\n"
		"affected by the rule, and returns 'True' if the symbol is the\n"
		"identifier of a Parameter object defined in the model.\n"
		"\n"
		"Returns 'True' if this Rule is a ParameterRule, 'False' otherwise.\n"
		"\n"
		""},
	 { "Rule_isRate", _wrap_Rule_isRate, METH_O, "\n"
		"Rule_isRate(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Rule is a RateRule (SBML Levels\n"
		"2-3) or has a 'type' attribute value of ''rate'' (SBML Level 1).\n"
		"\n"
		"Returns 'True' if this Rule is a RateRule (Level 2) or has type 'rate'\n"
		"(Level 1), 'False' otherwise.\n"
		"\n"
		""},
	 { "Rule_isScalar", _wrap_Rule_isScalar, METH_O, "\n"
		"Rule_isScalar(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Rule is an AssignmentRule (SBML\n"
		"Levels 2-3) or has a 'type' attribute value of ''scalar'' (SBML Level\n"
		"1).\n"
		"\n"
		"Returns 'True' if this Rule is an AssignmentRule (Level 2) or has type\n"
		"'scalar' (Level 1), 'False' otherwise.\n"
		"\n"
		""},
	 { "Rule_isSpeciesConcentration", _wrap_Rule_isSpeciesConcentration, METH_O, "\n"
		"Rule_isSpeciesConcentration(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Rule is a SpeciesConcentrationRule\n"
		"or equivalent.\n"
		"\n"
		"This libSBML method works for SBML Level 1 models (where there is such\n"
		"a thing as an explicit SpeciesConcentrationRule), as well as other\n"
		"Levels of SBML.  For Levels above Level 1, this method checks the\n"
		"symbol being affected by the rule, and returns 'True' if the symbol is\n"
		"the identifier of a Species object defined in the model.\n"
		"\n"
		"Returns 'True' if this Rule is a SpeciesConcentrationRule, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Rule_getTypeCode", _wrap_Rule_getTypeCode, METH_O, "\n"
		"Rule_getTypeCode(Rule self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object, either\n"
		"SBML_ASSIGNMENT_RULE, SBML_RATE_RULE, or SBML_ALGEBRAIC_RULE  for SBML\n"
		"Core.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "Rule_getL1TypeCode", _wrap_Rule_getL1TypeCode, METH_O, "\n"
		"Rule_getL1TypeCode(Rule self) -> int\n"
		"\n"
		"Returns the SBML Level 1 type code for this Rule object.\n"
		"\n"
		"This method only applies to SBML Level 1 model objects.  If this is\n"
		"not an SBML Level 1 rule object, this method will return SBML_UNKNOWN.\n"
		"\n"
		"Returns the SBML Level 1 type code for this Rule (namely,\n"
		"SBML_COMPARTMENT_VOLUME_RULE, SBML_PARAMETER_RULE,\n"
		"SBML_SPECIES_CONCENTRATION_RULE, or SBML_UNKNOWN).\n"
		"\n"
		""},
	 { "Rule_getElementName", _wrap_Rule_getElementName, METH_O, "\n"
		"Rule_getElementName(Rule self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"The returned value can be any of a number of different strings,\n"
		"depending on the SBML Level in use and the kind of Rule object this\n"
		"is.  The rules as of libSBML version 5.19.0 are the following:\n"
		"\n"
		"* (Level 2 and 3) RateRule: returns ''rateRule''\n"
		"\n"
		"* (Level 2 and 3) AssignmentRule: returns ''assignmentRule''\n"
		"\n"
		"* (Level 2 and 3) AlgebraicRule: returns ''algebraicRule''\n"
		"\n"
		"* (Level 1 Version 1) SpecieConcentrationRule: returns\n"
		"''specieConcentrationRule''\n"
		"\n"
		"* (Level 1 Version 2) SpeciesConcentrationRule: returns\n"
		"''speciesConcentrationRule''\n"
		"\n"
		"* (Level 1) CompartmentVolumeRule: returns\n"
		"''compartmentVolumeRule''\n"
		"\n"
		"* (Level 1) ParameterRule: returns ''parameterRule''\n"
		"\n"
		"* Unknown rule type: returns ''unknownRule'' Beware that the last\n"
		"(''unknownRule')' is not a valid SBML element name.\n"
		"\n"
		"Returns the name of this element.\n"
		"\n"
		""},
	 { "Rule_setL1TypeCode", _wrap_Rule_setL1TypeCode, METH_VARARGS, "\n"
		"Rule_setL1TypeCode(Rule self, int type) -> int\n"
		"\n"
		"Sets the SBML Level 1 type code for this Rule.\n"
		"\n"
		"Parameter 'type' is the SBML Level 1 type code for this Rule. The\n"
		"allowable values are SBML_COMPARTMENT_VOLUME_RULE,\n"
		"SBML_PARAMETER_RULE, and SBML_SPECIES_CONCENTRATION_RULE.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE if given 'type' value is not one\n"
		"of the above.\n"
		"\n"
		""},
	 { "Rule_hasRequiredElements", _wrap_Rule_hasRequiredElements, METH_O, "\n"
		"Rule_hasRequiredElements(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this Rule\n"
		"object have been set.\n"
		"\n"
		"The only required element for a Rule object is the 'math' subelement\n"
		"in SBML Level 2 and Level 3 Version 1.  In SBML Level 3 Version 2+, it\n"
		"is no longer required.\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "Rule_hasRequiredAttributes", _wrap_Rule_hasRequiredAttributes, METH_O, "\n"
		"Rule_hasRequiredAttributes(Rule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"Rule object have been set.\n"
		"\n"
		"The required attributes for a Rule object depend on the type of Rule\n"
		"it is.  For AssignmentRule and RateRule objects (and SBML Level 1's\n"
		"SpeciesConcentrationRule, CompartmentVolumeRule, and ParameterRule\n"
		"objects), the required attribute is 'variable'; for AlgebraicRule\n"
		"objects, there is no required attribute.\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Rule_renameSIdRefs", _wrap_Rule_renameSIdRefs, METH_VARARGS, "\n"
		"Rule_renameSIdRefs(Rule self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Rule_renameUnitSIdRefs", _wrap_Rule_renameUnitSIdRefs, METH_VARARGS, "\n"
		"Rule_renameUnitSIdRefs(Rule self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Rule_getId", _wrap_Rule_getId, METH_O, "\n"
		"Rule_getId(Rule self) -> string\n"
		"\n"
		"Returns the value of the 'variable' attribute of this Rule (NOT the\n"
		"'id').\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() or the getVariable() function instead.\n"
		"\n"
		"The 'variable' attribute of a Rule indicates the element which the\n"
		"results of the 'math' are to be applied.  An AlgebraicRule has no\n"
		"'variable', and will always return an empty string.\n"
		"\n"
		"Returns the variable of this Rule.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute(), getVariable().\n"
		"\n"
		""},
	 { "Rule_replaceSIDWithFunction", _wrap_Rule_replaceSIDWithFunction, METH_VARARGS, "\n"
		"Rule_replaceSIDWithFunction(Rule self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Rule_divideAssignmentsToSIdByFunction", _wrap_Rule_divideAssignmentsToSIdByFunction, METH_VARARGS, "\n"
		"Rule_divideAssignmentsToSIdByFunction(Rule self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Rule_multiplyAssignmentsToSIdByFunction", _wrap_Rule_multiplyAssignmentsToSIdByFunction, METH_VARARGS, "\n"
		"Rule_multiplyAssignmentsToSIdByFunction(Rule self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Rule_swigregister", Rule_swigregister, METH_O, NULL},
	 { "Rule_swiginit", Rule_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfRules", _wrap_new_ListOfRules, METH_VARARGS, "\n"
		"ListOfRules(unsigned int level, unsigned int version)\n"
		"new_ListOfRules(SBMLNamespaces sbmlns) -> ListOfRules\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfRules(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfRules object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfRules object to be created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfRules(long level, long version)\n"
		"\n"
		"Creates a new ListOfRules object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfRules_clone", _wrap_ListOfRules_clone, METH_O, "\n"
		"ListOfRules_clone(ListOfRules self) -> ListOfRules\n"
		"\n"
		"Creates and returns a deep copy of this ListOfRules object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfRules object.\n"
		"\n"
		""},
	 { "ListOfRules_getItemTypeCode", _wrap_ListOfRules_getItemTypeCode, METH_O, "\n"
		"ListOfRules_getItemTypeCode(ListOfRules self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., Rule objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for objects contained in this list:\n"
		"SBML_RULE (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfRules_getElementName", _wrap_ListOfRules_getElementName, METH_O, "\n"
		"ListOfRules_getElementName(ListOfRules self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfRules, the XML element name is ''listOfRules'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfRules'.'\n"
		"\n"
		""},
	 { "ListOfRules_get", _wrap_ListOfRules_get, METH_VARARGS, "\n"
		"ListOfRules_get(ListOfRules self, unsigned int n) -> Rule\n"
		"ListOfRules_get(ListOfRules self, unsigned int n) -> Rule\n"
		"ListOfRules_get(ListOfRules self, string sid) -> Rule\n"
		"ListOfRules_get(ListOfRules self, string sid) -> Rule\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Get a Rule from the ListOfRules.\n"
		"\n"
		"Parameter 'n' is the index number of the Rule to get.\n"
		"\n"
		"Returns the nth Rule in this ListOfRules. If the index 'n' is invalid,\n"
		"'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Get a Rule from the ListOfRules based on its identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier of the Rule to\n"
		"get.\n"
		"\n"
		"Returns Rule in this ListOfRules with the given 'sid' or 'None' if no\n"
		"such Rule exists.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfRules_getElementBySId", _wrap_ListOfRules_getElementBySId, METH_VARARGS, "\n"
		"ListOfRules_getElementBySId(ListOfRules self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given 'id' in the\n"
		"model-wide SId namespace, or 'None' if no such object is found.\n"
		"\n"
		"Note that AssignmentRules and RateRules do not actually have IDs, but\n"
		"the libsbml interface pretends that they do: no assignment rule or\n"
		"rate rule is returned by this function.\n"
		"\n"
		"Parameter 'id' is string representing the id of the object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'id'.\n"
		"\n"
		""},
	 { "ListOfRules_remove", _wrap_ListOfRules_remove, METH_VARARGS, "\n"
		"ListOfRules_remove(ListOfRules self, unsigned int n) -> Rule\n"
		"ListOfRules_remove(ListOfRules self, string sid) -> Rule\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfRules items and returns a pointer\n"
		"to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes item in this ListOfRules items with the given identifier.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"If none of the items in this list have the identifier 'sid', then\n"
		"'None' is returned.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  As mentioned above, the caller owns the\n"
		"returned item.\n"
		"\n"
		""},
	 { "delete_ListOfRules", _wrap_delete_ListOfRules, METH_O, "delete_ListOfRules(ListOfRules self)"},
	 { "ListOfRules_swigregister", ListOfRules_swigregister, METH_O, NULL},
	 { "ListOfRules_swiginit", ListOfRules_swiginit, METH_VARARGS, NULL},
	 { "new_AlgebraicRule", _wrap_new_AlgebraicRule, METH_VARARGS, "\n"
		"AlgebraicRule(unsigned int level, unsigned int version)\n"
		"new_AlgebraicRule(SBMLNamespaces sbmlns) -> AlgebraicRule\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    AlgebraicRule(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new AlgebraicRule object using the given SBMLNamespaces\n"
		"object 'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    AlgebraicRule(long level, long version)\n"
		"\n"
		"Creates a new AlgebraicRule object using the given SBML 'level' and\n"
		"'version' values.\n"
		"\n"
		"Parameter 'level' is the SBML Level to assign to this AlgebraicRule\n"
		"object.\n"
		"\n"
		"Parameter 'version' is the SBML Version to assign to this\n"
		"AlgebraicRule object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "delete_AlgebraicRule", _wrap_delete_AlgebraicRule, METH_O, "delete_AlgebraicRule(AlgebraicRule self)"},
	 { "AlgebraicRule_clone", _wrap_AlgebraicRule_clone, METH_O, "\n"
		"AlgebraicRule_clone(AlgebraicRule self) -> AlgebraicRule\n"
		"\n"
		"Creates and returns a deep copy of this AlgebraicRule object.\n"
		"\n"
		"Returns the (deep) copy of this Rule object.\n"
		"\n"
		""},
	 { "AlgebraicRule_hasRequiredAttributes", _wrap_AlgebraicRule_hasRequiredAttributes, METH_O, "\n"
		"AlgebraicRule_hasRequiredAttributes(AlgebraicRule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"AlgebraicRule object have been set.\n"
		"\n"
		"In SBML Levels 2-3, there is no required attribute for an\n"
		"AlgebraicRule object.  For Level 1, the only required attribute is\n"
		"'formula'.\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "AlgebraicRule_swigregister", AlgebraicRule_swigregister, METH_O, NULL},
	 { "AlgebraicRule_swiginit", AlgebraicRule_swiginit, METH_VARARGS, NULL},
	 { "new_AssignmentRule", _wrap_new_AssignmentRule, METH_VARARGS, "\n"
		"AssignmentRule(unsigned int level, unsigned int version)\n"
		"new_AssignmentRule(SBMLNamespaces sbmlns) -> AssignmentRule\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    AssignmentRule(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new AssignmentRule using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    AssignmentRule(long level, long version)\n"
		"\n"
		"Creates a new AssignmentRule using the given SBML 'level' and\n"
		"'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"AssignmentRule.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this AssignmentRule.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "delete_AssignmentRule", _wrap_delete_AssignmentRule, METH_O, "delete_AssignmentRule(AssignmentRule self)"},
	 { "AssignmentRule_clone", _wrap_AssignmentRule_clone, METH_O, "\n"
		"AssignmentRule_clone(AssignmentRule self) -> AssignmentRule\n"
		"\n"
		"Creates and returns a deep copy of this AssignmentRule object.\n"
		"\n"
		"Returns the (deep) copy of this Rule object.\n"
		"\n"
		""},
	 { "AssignmentRule_hasRequiredAttributes", _wrap_AssignmentRule_hasRequiredAttributes, METH_O, "\n"
		"AssignmentRule_hasRequiredAttributes(AssignmentRule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"AssignmentRule object have been set.\n"
		"\n"
		"In SBML Levels 2-3, the only required attribute for an AssignmentRule\n"
		"object is 'variable'.  For Level 1, where the equivalent attribute is\n"
		"known by different names ('compartment', 'species', or 'name',\n"
		"depending on the type of object), there is an additional required\n"
		"attribute called 'formula'.\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "AssignmentRule_renameSIdRefs", _wrap_AssignmentRule_renameSIdRefs, METH_VARARGS, "\n"
		"AssignmentRule_renameSIdRefs(AssignmentRule self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "AssignmentRule_swigregister", AssignmentRule_swigregister, METH_O, NULL},
	 { "AssignmentRule_swiginit", AssignmentRule_swiginit, METH_VARARGS, NULL},
	 { "new_RateRule", _wrap_new_RateRule, METH_VARARGS, "\n"
		"RateRule(unsigned int level, unsigned int version)\n"
		"new_RateRule(SBMLNamespaces sbmlns) -> RateRule\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    RateRule(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new RateRule using the given SBMLNamespaces object 'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    RateRule(long level, long version)\n"
		"\n"
		"Creates a new RateRule using the given SBML 'level' and 'version'\n"
		"values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"RateRule.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this RateRule.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "delete_RateRule", _wrap_delete_RateRule, METH_O, "delete_RateRule(RateRule self)"},
	 { "RateRule_clone", _wrap_RateRule_clone, METH_O, "\n"
		"RateRule_clone(RateRule self) -> RateRule\n"
		"\n"
		"Creates and returns a deep copy of this RateRule object.\n"
		"\n"
		"Returns the (deep) copy of this RateRule object.\n"
		"\n"
		""},
	 { "RateRule_hasRequiredAttributes", _wrap_RateRule_hasRequiredAttributes, METH_O, "\n"
		"RateRule_hasRequiredAttributes(RateRule self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"RateRule object have been set.\n"
		"\n"
		"In SBML Levels 2-3, the only required attribute for a RateRule object\n"
		"is 'variable'.  For Level 1, where the equivalent attribute is known\n"
		"by different names ('compartment', 'species', or 'name', depending on\n"
		"the type of object), there is an additional required attribute called\n"
		"'formula'.\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "RateRule_renameSIdRefs", _wrap_RateRule_renameSIdRefs, METH_VARARGS, "\n"
		"RateRule_renameSIdRefs(RateRule self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "RateRule_swigregister", RateRule_swigregister, METH_O, NULL},
	 { "RateRule_swiginit", RateRule_swiginit, METH_VARARGS, NULL},
	 { "delete_Constraint", _wrap_delete_Constraint, METH_O, "delete_Constraint(Constraint self)"},
	 { "new_Constraint", _wrap_new_Constraint, METH_VARARGS, "\n"
		"Constraint(unsigned int level, unsigned int version)\n"
		"Constraint(SBMLNamespaces sbmlns)\n"
		"new_Constraint(Constraint orig) -> Constraint\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Constraint(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new Constraint using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Constraint(long level, long version)\n"
		"\n"
		"Creates a new Constraint using the given SBML 'level' and 'version'\n"
		"values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"Constraint.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this Constraint.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Constraint( Constraint orig)\n"
		"\n"
		"Copy constructor; creates a copy of this Constraint.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "Constraint_clone", _wrap_Constraint_clone, METH_O, "\n"
		"Constraint_clone(Constraint self) -> Constraint\n"
		"\n"
		"Creates and returns a deep copy of this Constraint object.\n"
		"\n"
		"Returns the (deep) copy of this Constraint object.\n"
		"\n"
		""},
	 { "Constraint_getMessage", _wrap_Constraint_getMessage, METH_O, "\n"
		"Constraint_getMessage(Constraint self) -> XMLNode\n"
		"\n"
		"Get the message, if any, associated with this Constraint\n"
		"\n"
		"Returns the message for this Constraint, as an XMLNode.\n"
		"\n"
		""},
	 { "Constraint_getMessageString", _wrap_Constraint_getMessageString, METH_O, "\n"
		"Constraint_getMessageString(Constraint self) -> string\n"
		"\n"
		"Get the message string, if any, associated with this Constraint\n"
		"\n"
		"Returns the message for this Constraint, as a string.\n"
		"\n"
		""},
	 { "Constraint_getMath", _wrap_Constraint_getMath, METH_O, "\n"
		"Constraint_getMath(Constraint self) -> ASTNode\n"
		"\n"
		"Get the mathematical expression of this Constraint\n"
		"\n"
		"Returns the math for this Constraint, as an ASTNode, or 'None' if the\n"
		"math is not set.\n"
		"\n"
		""},
	 { "Constraint_isSetMessage", _wrap_Constraint_isSetMessage, METH_O, "\n"
		"Constraint_isSetMessage(Constraint self) -> bool\n"
		"\n"
		"Predicate returning 'True' if a message is defined for this\n"
		"Constraint.\n"
		"\n"
		"Returns 'True' if the message of this Constraint is set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Constraint_isSetMath", _wrap_Constraint_isSetMath, METH_O, "\n"
		"Constraint_isSetMath(Constraint self) -> bool\n"
		"\n"
		"Predicate returning 'True' if a mathematical formula is defined for\n"
		"this Constraint.\n"
		"\n"
		"Returns 'True' if the 'math' subelement for this Constraint is set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "Constraint_setMessage", _wrap_Constraint_setMessage, METH_VARARGS, "\n"
		"Constraint_setMessage(Constraint self, XMLNode xhtml) -> int\n"
		"Constraint_setMessage(Constraint self, string message, bool addXHTMLMarkup=False) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setMessage(string message, bool addXHTMLMarkup = false)\n"
		"\n"
		"Sets the message of this Constraint.\n"
		"\n"
		"Parameter 'message' is an XML string that is to be used as the content\n"
		"of the 'message' subelement of this object.\n"
		"\n"
		"Parameter 'addXHTMLMarkup' is a boolean indicating whether to wrap the\n"
		"contents of the 'message' argument with XHTML paragraph (<p>) tags.\n"
		"This is appropriate when the string in 'message' does not already\n"
		"containg the appropriate XHTML markup.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setMessage(XMLNode xhtml)\n"
		"\n"
		"Sets the message of this Constraint.\n"
		"\n"
		"The XMLNode tree passed in 'xhtml' is copied.\n"
		"\n"
		"Parameter 'xhtml' is an XML tree containing XHTML content.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "Constraint_setMath", _wrap_Constraint_setMath, METH_VARARGS, "\n"
		"Constraint_setMath(Constraint self, ASTNode math) -> int\n"
		"\n"
		"Sets the mathematical expression of this Constraint to a copy of the\n"
		"AST given as 'math'.\n"
		"\n"
		"Parameter 'math' is an ASTNode expression to be assigned as the 'math'\n"
		"subelement of this Constraint.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "Constraint_unsetMessage", _wrap_Constraint_unsetMessage, METH_O, "\n"
		"Constraint_unsetMessage(Constraint self) -> int\n"
		"\n"
		"Unsets the 'message' subelement of this Constraint.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Constraint_renameSIdRefs", _wrap_Constraint_renameSIdRefs, METH_VARARGS, "\n"
		"Constraint_renameSIdRefs(Constraint self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Constraint_renameUnitSIdRefs", _wrap_Constraint_renameUnitSIdRefs, METH_VARARGS, "\n"
		"Constraint_renameUnitSIdRefs(Constraint self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Constraint_replaceSIDWithFunction", _wrap_Constraint_replaceSIDWithFunction, METH_VARARGS, "\n"
		"Constraint_replaceSIDWithFunction(Constraint self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Constraint_getTypeCode", _wrap_Constraint_getTypeCode, METH_O, "\n"
		"Constraint_getTypeCode(Constraint self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_CONSTRAINT (default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "Constraint_getElementName", _wrap_Constraint_getElementName, METH_O, "\n"
		"Constraint_getElementName(Constraint self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for Constraint, is\n"
		"always ''constraint'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''constraint'.'\n"
		"\n"
		""},
	 { "Constraint_hasRequiredElements", _wrap_Constraint_hasRequiredElements, METH_O, "\n"
		"Constraint_hasRequiredElements(Constraint self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this\n"
		"Constraint object have been set.\n"
		"\n"
		"Note: The required elements for a Constraint object are:\n"
		"\n"
		"* 'math' (through SBML Level 3 Version 1 only; not  required in\n"
		"Level 3 Version 2+.)\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "Constraint_swigregister", Constraint_swigregister, METH_O, NULL},
	 { "Constraint_swiginit", Constraint_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfConstraints", _wrap_new_ListOfConstraints, METH_VARARGS, "\n"
		"ListOfConstraints(unsigned int level, unsigned int version)\n"
		"new_ListOfConstraints(SBMLNamespaces sbmlns) -> ListOfConstraints\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfConstraints(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfConstraints object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfConstraints object to be\n"
		"created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfConstraints(long level, long version)\n"
		"\n"
		"Creates a new ListOfConstraints object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfConstraints_clone", _wrap_ListOfConstraints_clone, METH_O, "\n"
		"ListOfConstraints_clone(ListOfConstraints self) -> ListOfConstraints\n"
		"\n"
		"Creates and returns a deep copy of this ListOfConstraints object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfConstraints object.\n"
		"\n"
		""},
	 { "ListOfConstraints_getItemTypeCode", _wrap_ListOfConstraints_getItemTypeCode, METH_O, "\n"
		"ListOfConstraints_getItemTypeCode(ListOfConstraints self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., Constraint objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for the objects contained in this ListOf\n"
		"instance: SBML_CONSTRAINT (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfConstraints_getElementName", _wrap_ListOfConstraints_getElementName, METH_O, "\n"
		"ListOfConstraints_getElementName(ListOfConstraints self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfConstraints, the XML element name is ''listOfConstraints'.'\n"
		"\n"
		"Returns the name of this element.\n"
		"\n"
		""},
	 { "ListOfConstraints_get", _wrap_ListOfConstraints_get, METH_VARARGS, "\n"
		"ListOfConstraints_get(ListOfConstraints self, unsigned int n) -> Constraint\n"
		"ListOfConstraints_get(ListOfConstraints self, unsigned int n) -> Constraint\n"
		"\n"
		"Get a Constraint from the ListOfConstraints.\n"
		"\n"
		"Parameter 'n' is the index number of the Constraint to get.\n"
		"\n"
		"Returns the nth Constraint in this ListOfConstraints. If the index 'n'\n"
		"is invalid, 'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		""},
	 { "ListOfConstraints_remove", _wrap_ListOfConstraints_remove, METH_VARARGS, "\n"
		"ListOfConstraints_remove(ListOfConstraints self, unsigned int n) -> Constraint\n"
		"\n"
		"Removes the nth item from this ListOfConstraints items and returns a\n"
		"pointer to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		""},
	 { "delete_ListOfConstraints", _wrap_delete_ListOfConstraints, METH_O, "delete_ListOfConstraints(ListOfConstraints self)"},
	 { "ListOfConstraints_swigregister", ListOfConstraints_swigregister, METH_O, NULL},
	 { "ListOfConstraints_swiginit", ListOfConstraints_swiginit, METH_VARARGS, NULL},
	 { "delete_Reaction", _wrap_delete_Reaction, METH_O, "delete_Reaction(Reaction self)"},
	 { "new_Reaction", _wrap_new_Reaction, METH_VARARGS, "\n"
		"Reaction(unsigned int level, unsigned int version)\n"
		"Reaction(SBMLNamespaces sbmlns)\n"
		"new_Reaction(Reaction orig) -> Reaction\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Reaction(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new Reaction using the given SBMLNamespaces object 'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Reaction(long level, long version)\n"
		"\n"
		"Creates a new Reaction using the given SBML 'level' and 'version'\n"
		"values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"Reaction.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this Reaction.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Reaction(Reaction orig)\n"
		"\n"
		"Copy constructor; creates a copy of this Reaction.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "Reaction_clone", _wrap_Reaction_clone, METH_O, "\n"
		"Reaction_clone(Reaction self) -> Reaction\n"
		"\n"
		"Creates and returns a deep copy of this Reaction object.\n"
		"\n"
		"Returns the (deep) copy of this Reaction object.\n"
		"\n"
		""},
	 { "Reaction_getElementBySId", _wrap_Reaction_getElementBySId, METH_VARARGS, "\n"
		"Reaction_getElementBySId(Reaction self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given 'id' in the\n"
		"model-wide SId namespace, or 'None' if no such object is found.\n"
		"\n"
		"Parameter 'id' is string representing the id of the object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'id'.\n"
		"\n"
		""},
	 { "Reaction_getElementByMetaId", _wrap_Reaction_getElementByMetaId, METH_VARARGS, "\n"
		"Reaction_getElementByMetaId(Reaction self, string metaid) -> SBase\n"
		"\n"
		"Returns the first child element it can find with the given 'metaid',\n"
		"or 'None' if no such object is found.\n"
		"\n"
		"Parameter 'metaid' is string representing the metaid of the object to\n"
		"find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'metaid'.\n"
		"\n"
		""},
	 { "Reaction_renameSIdRefs", _wrap_Reaction_renameSIdRefs, METH_VARARGS, "\n"
		"Reaction_renameSIdRefs(Reaction self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Reaction_initDefaults", _wrap_Reaction_initDefaults, METH_O, "\n"
		"Reaction_initDefaults(Reaction self)\n"
		"\n"
		"Initializes the fields of this Reaction object to 'typical' default\n"
		"values.\n"
		"\n"
		"The SBML Reaction component has slightly different aspects and default\n"
		"attribute values in different SBML Levels and Versions. This method\n"
		"sets the values to certain common defaults, based mostly on what they\n"
		"are in SBML Level 2.  Specifically:\n"
		"\n"
		"* Sets the 'reversible' attribute to 'True'\n"
		"\n"
		"* Sets the 'fast' attribute to 'False'\n"
		"\n"
		"* Marks the 'fast' attribute as not having been set for SBML Level\n"
		"2, but as having been set for SBML Level 1 and SBML Level 3.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"SBML definitions before SBML Level 2 Version 2 incorrectly indicated\n"
		"that software tools could ignore the 'fast' attribute if they did not\n"
		"implement support for the corresponding concept; however, further\n"
		"research in SBML has revealed that this is not true, and 'fast' cannot\n"
		"be ignored if it is set to 'True.' Beginning with SBML Level 2\n"
		"Versions 2, the SBML specifications therefore stipulate that if a\n"
		"model has any reactions with 'fast' set to 'True,' a software tool\n"
		"must be able to respect the attribute or else indicate to the user\n"
		"that it does not have the capacity to do so.  Readers are directed to\n"
		"the SBML specifications, which provides more detail about the\n"
		"conditions under which a reaction can be considered to be fast in this\n"
		"sense.\n"
		"\n"
		""},
	 { "Reaction_getId", _wrap_Reaction_getId, METH_O, "\n"
		"Reaction_getId(Reaction self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this Reaction.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() function instead.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this Reaction.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Reaction_getName", _wrap_Reaction_getName, METH_O, "\n"
		"Reaction_getName(Reaction self) -> string\n"
		"\n"
		"Returns the value of the 'name' attribute of this Reaction object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns the name of this SBML object, or the empty string if not set\n"
		"or unsettable.\n"
		"\n"
		"See also getIdAttribute(), isSetName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "Reaction_getKineticLaw", _wrap_Reaction_getKineticLaw, METH_VARARGS, "\n"
		"Reaction_getKineticLaw(Reaction self) -> KineticLaw\n"
		"Reaction_getKineticLaw(Reaction self) -> KineticLaw\n"
		"\n"
		"Returns the KineticLaw object contained in this Reaction.\n"
		"\n"
		"Returns the KineticLaw instance.\n"
		"\n"
		""},
	 { "Reaction_getReversible", _wrap_Reaction_getReversible, METH_O, "\n"
		"Reaction_getReversible(Reaction self) -> bool\n"
		"\n"
		"Returns the value of the 'reversible' attribute on the Reaction as a\n"
		"boolean value.\n"
		"\n"
		"Returns the reversibility status of this Reaction.\n"
		"\n"
		""},
	 { "Reaction_getFast", _wrap_Reaction_getFast, METH_O, "\n"
		"Reaction_getFast(Reaction self) -> bool\n"
		"\n"
		"Returns the value of the 'fast' attribute of this Reaction.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'fast' attribute was  removed.  All\n"
		"reactions are assumed to be equivalent to reactions in previous\n"
		"levels/versions that have a 'fast' attribute value of 'False.'  Users\n"
		"should be aware that even for previous levels/versions of the\n"
		"specification, 'fast' attribute values of 'True' never achieved\n"
		"widespread support, and many software packages may ignore it.  To\n"
		"achieve the same or similar  effects as setting the fast attribute to\n"
		"'True' for a given  reaction, the KineticLaw attribute should be\n"
		"constructed to  produce a value in the desired time scale, or else the\n"
		"reaction could be replaced with an AssignmentRule or  AlgebraicRule.\n"
		"\n"
		"Returns the 'fast' status of this Reaction.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"SBML definitions before SBML Level 2 Version 2 incorrectly indicated\n"
		"that software tools could ignore the 'fast' attribute if they did not\n"
		"implement support for the corresponding concept; however, further\n"
		"research in SBML has revealed that this is not true, and 'fast' cannot\n"
		"be ignored if it is set to 'True.' Beginning with SBML Level 2\n"
		"Versions 2, the SBML specifications therefore stipulate that if a\n"
		"model has any reactions with 'fast' set to 'True,' a software tool\n"
		"must be able to respect the attribute or else indicate to the user\n"
		"that it does not have the capacity to do so.  Readers are directed to\n"
		"the SBML specifications, which provides more detail about the\n"
		"conditions under which a reaction can be considered to be fast in this\n"
		"sense.\n"
		"\n"
		""},
	 { "Reaction_getCompartment", _wrap_Reaction_getCompartment, METH_O, "\n"
		"Reaction_getCompartment(Reaction self) -> string\n"
		"\n"
		"(SBML Level 3 only) Returns the value of the 'compartment' attribute\n"
		"on the Reaction.\n"
		"\n"
		"Returns the compartment of this Reaction.\n"
		"\n"
		"Note: The 'compartment' attribute is available in SBML Level 3, but is\n"
		"not present on Reaction in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Reaction_isSetId", _wrap_Reaction_isSetId, METH_O, "\n"
		"Reaction_isSetId(Reaction self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Reaction's 'id' attribute is set.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is recommended that callers use\n"
		"isSetIdAttribute() instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),\n"
		"isSetIdAttribute().\n"
		"\n"
		""},
	 { "Reaction_isSetName", _wrap_Reaction_isSetName, METH_O, "\n"
		"Reaction_isSetName(Reaction self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Reaction's 'name' attribute is set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns 'True' if the 'name' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "Reaction_isSetKineticLaw", _wrap_Reaction_isSetKineticLaw, METH_O, "\n"
		"Reaction_isSetKineticLaw(Reaction self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Reaction contains a kinetic law\n"
		"object.\n"
		"\n"
		"Returns 'True' if a KineticLaw is present in this Reaction,, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Reaction_isSetFast", _wrap_Reaction_isSetFast, METH_O, "\n"
		"Reaction_isSetFast(Reaction self) -> bool\n"
		"\n"
		"Predicate returning 'True' if the value of the 'fast' attribute on\n"
		"this Reaction is set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'fast' attribute was  removed.  All\n"
		"reactions are assumed to be equivalent to reactions in previous\n"
		"levels/versions that have a 'fast' attribute value of 'False.'  Users\n"
		"should be aware that even for previous levels/versions of the\n"
		"specification, 'fast' attribute values of 'True' never achieved\n"
		"widespread support, and many software packages may ignore it.  To\n"
		"achieve the same or similar  effects as setting the fast attribute to\n"
		"'True' for a given  reaction, the KineticLaw attribute should be\n"
		"constructed to  produce a value in the desired time scale, or else the\n"
		"reaction could be replaced with an AssignmentRule or  AlgebraicRule.\n"
		"\n"
		"Returns 'True' if the 'fast' attribute is set, 'False' otherwise.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"SBML definitions before SBML Level 2 Version 2 incorrectly indicated\n"
		"that software tools could ignore the 'fast' attribute if they did not\n"
		"implement support for the corresponding concept; however, further\n"
		"research in SBML has revealed that this is not true, and 'fast' cannot\n"
		"be ignored if it is set to 'True.' Beginning with SBML Level 2\n"
		"Versions 2, the SBML specifications therefore stipulate that if a\n"
		"model has any reactions with 'fast' set to 'True,' a software tool\n"
		"must be able to respect the attribute or else indicate to the user\n"
		"that it does not have the capacity to do so.  Readers are directed to\n"
		"the SBML specifications, which provides more detail about the\n"
		"conditions under which a reaction can be considered to be fast in this\n"
		"sense.\n"
		"\n"
		""},
	 { "Reaction_isSetCompartment", _wrap_Reaction_isSetCompartment, METH_O, "\n"
		"Reaction_isSetCompartment(Reaction self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Reaction's 'compartment' attribute\n"
		"is set.\n"
		"\n"
		"Returns 'True' if the 'compartment' attribute of this Reaction is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The 'compartment' attribute is available in SBML Level 3, but is\n"
		"not present on Reaction in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Reaction_isSetReversible", _wrap_Reaction_isSetReversible, METH_O, "\n"
		"Reaction_isSetReversible(Reaction self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Reaction's 'reversible' attribute\n"
		"is set.\n"
		"\n"
		"Returns 'True' if the 'reversible' attribute of this Reaction is set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "Reaction_setId", _wrap_Reaction_setId, METH_VARARGS, "\n"
		"Reaction_setId(Reaction self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this Reaction.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Reaction_setName", _wrap_Reaction_setName, METH_VARARGS, "\n"
		"Reaction_setName(Reaction self, string name) -> int\n"
		"\n"
		"Sets the value of the 'name' attribute of this Reaction.\n"
		"\n"
		"The string in 'name' is copied.\n"
		"\n"
		"Parameter 'name' is the new name for the SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Reaction_setKineticLaw", _wrap_Reaction_setKineticLaw, METH_VARARGS, "\n"
		"Reaction_setKineticLaw(Reaction self, KineticLaw kl) -> int\n"
		"\n"
		"Sets the 'kineticLaw' subelement of this Reaction to a copy of the\n"
		"given KineticLaw object.\n"
		"\n"
		"Parameter 'kl' is the KineticLaw object to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		""},
	 { "Reaction_setReversible", _wrap_Reaction_setReversible, METH_VARARGS, "\n"
		"Reaction_setReversible(Reaction self, bool value) -> int\n"
		"\n"
		"Sets the value of the 'reversible' attribute of this Reaction.\n"
		"\n"
		"Parameter 'value' is the value of the 'reversible' attribute.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "Reaction_setFast", _wrap_Reaction_setFast, METH_VARARGS, "\n"
		"Reaction_setFast(Reaction self, bool value) -> int\n"
		"\n"
		"Sets the value of the 'fast' attribute of this Reaction.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'fast' attribute was  removed.  All\n"
		"reactions are assumed to be equivalent to reactions in previous\n"
		"levels/versions that have a 'fast' attribute value of 'False.'  Users\n"
		"should be aware that even for previous levels/versions of the\n"
		"specification, 'fast' attribute values of 'True' never achieved\n"
		"widespread support, and many software packages may ignore it.  To\n"
		"achieve the same or similar  effects as setting the fast attribute to\n"
		"'True' for a given  reaction, the KineticLaw attribute should be\n"
		"constructed to  produce a value in the desired time scale, or else the\n"
		"reaction could be replaced with an AssignmentRule or  AlgebraicRule.\n"
		"\n"
		"Calling this function with an argument of 'True' for an SBML Level 3\n"
		"Version 2 Reaction will not set the value, as the attribute does not\n"
		"exist for that level/version.\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Parameter 'value' is the value of the 'fast' attribute.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"WARNING:\n"
		"\n"
		"SBML definitions before SBML Level 2 Version 2 incorrectly indicated\n"
		"that software tools could ignore the 'fast' attribute if they did not\n"
		"implement support for the corresponding concept; however, further\n"
		"research in SBML has revealed that this is not true, and 'fast' cannot\n"
		"be ignored if it is set to 'True.' Beginning with SBML Level 2\n"
		"Versions 2, the SBML specifications therefore stipulate that if a\n"
		"model has any reactions with 'fast' set to 'True,' a software tool\n"
		"must be able to respect the attribute or else indicate to the user\n"
		"that it does not have the capacity to do so.  Readers are directed to\n"
		"the SBML specifications, which provides more detail about the\n"
		"conditions under which a reaction can be considered to be fast in this\n"
		"sense.\n"
		"\n"
		""},
	 { "Reaction_setCompartment", _wrap_Reaction_setCompartment, METH_VARARGS, "\n"
		"Reaction_setCompartment(Reaction self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'compartment' attribute of this Reaction.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"Parameter 'sid' is the string to use as the compartment of this\n"
		"Reaction.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: The 'compartment' attribute is available in SBML Level 3, but is\n"
		"not present on Reaction in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Reaction_unsetName", _wrap_Reaction_unsetName, METH_O, "\n"
		"Reaction_unsetName(Reaction self) -> int\n"
		"\n"
		"Unsets the value of the 'name' attribute of this Reaction.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getName(), setName(), isSetName().\n"
		"\n"
		""},
	 { "Reaction_unsetKineticLaw", _wrap_Reaction_unsetKineticLaw, METH_O, "\n"
		"Reaction_unsetKineticLaw(Reaction self) -> int\n"
		"\n"
		"Unsets the 'kineticLaw' subelement of this Reaction.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Reaction_unsetFast", _wrap_Reaction_unsetFast, METH_O, "\n"
		"Reaction_unsetFast(Reaction self) -> int\n"
		"\n"
		"Unsets the value of the 'fast' attribute of this Reaction.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'fast' attribute was  removed.  All\n"
		"reactions are assumed to be equivalent to reactions in previous\n"
		"levels/versions that have a 'fast' attribute value of 'False.'  Users\n"
		"should be aware that even for previous levels/versions of the\n"
		"specification, 'fast' attribute values of 'True' never achieved\n"
		"widespread support, and many software packages may ignore it.  To\n"
		"achieve the same or similar  effects as setting the fast attribute to\n"
		"'True' for a given  reaction, the KineticLaw attribute should be\n"
		"constructed to  produce a value in the desired time scale, or else the\n"
		"reaction could be replaced with an AssignmentRule or  AlgebraicRule.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"WARNING:\n"
		"\n"
		"SBML definitions before SBML Level 2 Version 2 incorrectly indicated\n"
		"that software tools could ignore the 'fast' attribute if they did not\n"
		"implement support for the corresponding concept; however, further\n"
		"research in SBML has revealed that this is not true, and 'fast' cannot\n"
		"be ignored if it is set to 'True.' Beginning with SBML Level 2\n"
		"Versions 2, the SBML specifications therefore stipulate that if a\n"
		"model has any reactions with 'fast' set to 'True,' a software tool\n"
		"must be able to respect the attribute or else indicate to the user\n"
		"that it does not have the capacity to do so.  Readers are directed to\n"
		"the SBML specifications, which provides more detail about the\n"
		"conditions under which a reaction can be considered to be fast in this\n"
		"sense.\n"
		"\n"
		""},
	 { "Reaction_unsetCompartment", _wrap_Reaction_unsetCompartment, METH_O, "\n"
		"Reaction_unsetCompartment(Reaction self) -> int\n"
		"\n"
		"Unsets the value of the 'compartment' attribute of this Reaction.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The 'compartment' attribute is available in SBML Level 3, but is\n"
		"not present on Reaction in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Reaction_unsetReversible", _wrap_Reaction_unsetReversible, METH_O, "\n"
		"Reaction_unsetReversible(Reaction self) -> int\n"
		"\n"
		"Unsets the value of the 'reversible' attribute of this Reaction.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Reaction_addReactant", _wrap_Reaction_addReactant, METH_VARARGS, "\n"
		"Reaction_addReactant(Reaction self, SpeciesReference sr) -> int\n"
		"Reaction_addReactant(Reaction self, Species species, double stoichiometry=1.0, string id=\"\", bool constant=True) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addReactant(Species species, double stoichiometry = 1.0,\n"
		"string id = '', bool constant = true)\n"
		"\n"
		"Adds the given species as a reactant with the given stoichiometry\n"
		"\n"
		"Parameter 'species' is the species to be added as reactant.\n"
		"\n"
		"Parameter 'stoichiometry' is an optional parameter specifying the\n"
		"stoichiometry of the added reactant (defaulting to 1).\n"
		"\n"
		"Parameter 'id' is an optional id to be given to the species reference\n"
		"that will be created. (defaulting to empty string, i.e. not set).\n"
		"\n"
		"Parameter 'constant' is an attribute specifying whether the species\n"
		"reference is constant or not (defaulting to true).\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"Note: the Species object itself is NOT added to the model\n"
		"\n"
		"See also createProduct().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addReactant(SpeciesReference sr)\n"
		"\n"
		"Adds a given SpeciesReference object as a reactant in this Reaction.\n"
		"\n"
		"The SpeciesReference instance in 'sr' is copied.\n"
		"\n"
		"Parameter 'sr' is a SpeciesReference object referring to a Species in\n"
		"the enclosing Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createReactant().\n"
		"\n"
		""},
	 { "Reaction_addProduct", _wrap_Reaction_addProduct, METH_VARARGS, "\n"
		"Reaction_addProduct(Reaction self, SpeciesReference sr) -> int\n"
		"Reaction_addProduct(Reaction self, Species species, double stoichiometry=1.0, string id=\"\", bool constant=True) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addProduct(Species species, double stoichiometry = 1.0,\n"
		"string id = '', bool constant = true)\n"
		"\n"
		"Adds the given species as a product with the given stoichiometry\n"
		"\n"
		"Parameter 'species' is the species to be added as product.\n"
		"\n"
		"Parameter 'stoichiometry' is an optional parameter specifying the\n"
		"stoichiometry of the added product (defaulting to 1).\n"
		"\n"
		"Parameter 'id' is an optional id to be given to the species reference\n"
		"that will be created. (defaulting to empty string, i.e. not set).\n"
		"\n"
		"Parameter 'constant' is an attribute specifying whether the species\n"
		"reference is constant or not (defaulting to true).\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"Note: the Species object itself is NOT added to the model\n"
		"\n"
		"See also createProduct().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addProduct(SpeciesReference sr)\n"
		"\n"
		"Adds a given SpeciesReference object as a product in this Reaction.\n"
		"\n"
		"The SpeciesReference instance in 'sr' is copied.\n"
		"\n"
		"Parameter 'sr' is a SpeciesReference object referring to a Species in\n"
		"the enclosing Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createProduct().\n"
		"\n"
		""},
	 { "Reaction_addModifier", _wrap_Reaction_addModifier, METH_VARARGS, "\n"
		"Reaction_addModifier(Reaction self, ModifierSpeciesReference msr) -> int\n"
		"Reaction_addModifier(Reaction self, Species species, string id=\"\") -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addModifier(Species species, string id = '')\n"
		"\n"
		"Adds the given species as a modifier to this reaction\n"
		"\n"
		"Parameter 'species' is the species to be added as modifier.\n"
		"\n"
		"Parameter 'id' is an optional id to be given to the species reference\n"
		"that will be created. (defaulting to empty string, i.e. not set).\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"Note: the Species object itself is NOT added to the model\n"
		"\n"
		"See also createModifier().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addModifier(ModifierSpeciesReference msr)\n"
		"\n"
		"Adds a given ModifierSpeciesReference object as a product in this\n"
		"Reaction.\n"
		"\n"
		"The ModifierSpeciesReference instance in 'msr' is copied.\n"
		"\n"
		"Parameter 'msr' is a ModifierSpeciesReference object referring to a\n"
		"Species in the enclosing Model.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createModifier().\n"
		"\n"
		""},
	 { "Reaction_createReactant", _wrap_Reaction_createReactant, METH_O, "\n"
		"Reaction_createReactant(Reaction self) -> SpeciesReference\n"
		"\n"
		"Creates a new SpeciesReference, adds it to this Reaction's list of\n"
		"reactants, and returns it.\n"
		"\n"
		"Returns a new SpeciesReference object.\n"
		"\n"
		""},
	 { "Reaction_createProduct", _wrap_Reaction_createProduct, METH_O, "\n"
		"Reaction_createProduct(Reaction self) -> SpeciesReference\n"
		"\n"
		"Creates a new SpeciesReference, adds it to this Reaction's list of\n"
		"products, and returns it.\n"
		"\n"
		"Returns a new SpeciesReference object.\n"
		"\n"
		""},
	 { "Reaction_createModifier", _wrap_Reaction_createModifier, METH_O, "\n"
		"Reaction_createModifier(Reaction self) -> ModifierSpeciesReference\n"
		"\n"
		"Creates a new ModifierSpeciesReference, adds it to this Reaction's\n"
		"list of modifiers and returns it.\n"
		"\n"
		"Returns a new ModifierSpeciesReference object.\n"
		"\n"
		""},
	 { "Reaction_createKineticLaw", _wrap_Reaction_createKineticLaw, METH_O, "\n"
		"Reaction_createKineticLaw(Reaction self) -> KineticLaw\n"
		"\n"
		"Creates a new KineticLaw object, installs it as this Reaction's\n"
		"'kineticLaw' subelement, and returns it.\n"
		"\n"
		"If this Reaction had a previous KineticLaw, it will be destroyed.\n"
		"\n"
		"Returns the new KineticLaw object.\n"
		"\n"
		""},
	 { "Reaction_getListOfReactants", _wrap_Reaction_getListOfReactants, METH_VARARGS, "\n"
		"Reaction_getListOfReactants(Reaction self) -> ListOfSpeciesReferences\n"
		"Reaction_getListOfReactants(Reaction self) -> ListOfSpeciesReferences\n"
		"\n"
		"Returns the list of reactants in this Reaction object.\n"
		"\n"
		"Returns the ListOfSpeciesReferences containing the references to the\n"
		"species acting as reactants in this reaction.\n"
		"\n"
		""},
	 { "Reaction_getListOfProducts", _wrap_Reaction_getListOfProducts, METH_VARARGS, "\n"
		"Reaction_getListOfProducts(Reaction self) -> ListOfSpeciesReferences\n"
		"Reaction_getListOfProducts(Reaction self) -> ListOfSpeciesReferences\n"
		"\n"
		"Returns the list of products in this Reaction object.\n"
		"\n"
		"Returns the ListOfSpeciesReferences containing the references to the\n"
		"species acting as products in this reaction.\n"
		"\n"
		""},
	 { "Reaction_getListOfModifiers", _wrap_Reaction_getListOfModifiers, METH_VARARGS, "\n"
		"Reaction_getListOfModifiers(Reaction self) -> ListOfSpeciesReferences\n"
		"Reaction_getListOfModifiers(Reaction self) -> ListOfSpeciesReferences\n"
		"\n"
		"Returns the list of modifiers in this Reaction object.\n"
		"\n"
		"Returns the ListOfSpeciesReferences containing the references to the\n"
		"species acting as modifiers in this reaction.\n"
		"\n"
		""},
	 { "Reaction_getReactant", _wrap_Reaction_getReactant, METH_VARARGS, "\n"
		"Reaction_getReactant(Reaction self, unsigned int n) -> SpeciesReference\n"
		"Reaction_getReactant(Reaction self, unsigned int n) -> SpeciesReference\n"
		"Reaction_getReactant(Reaction self, string species) -> SpeciesReference\n"
		"Reaction_getReactant(Reaction self, string species) -> SpeciesReference\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getReactant(string species)\n"
		"\n"
		"Returns the reactant species (as a SpeciesReference object) having  a\n"
		"specific identifier in this Reaction.\n"
		"\n"
		"Parameter 'species' is the identifier of the reactant Species\n"
		"('species'  attribute of the reactant SpeciesReference object).\n"
		"\n"
		"Returns a SpeciesReference object, or 'None' if no species with the\n"
		"given identifier 'species' appears as a reactant in this Reaction.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getReactant(long n)\n"
		"\n"
		"Returns the nth reactant species (as a SpeciesReference object)  in\n"
		"the list of reactants in this Reaction.\n"
		"\n"
		"Callers should first call getNumReactants() to find out how many\n"
		"reactants there are, to avoid using an invalid index number.\n"
		"\n"
		"Parameter 'n' is the index of the reactant sought.\n"
		"\n"
		"Returns the nth reactant (as a SpeciesReference object) of this\n"
		"Reaction. If the index 'n' is invalid, 'None' is returned.\n"
		"\n"
		""},
	 { "Reaction_getProduct", _wrap_Reaction_getProduct, METH_VARARGS, "\n"
		"Reaction_getProduct(Reaction self, unsigned int n) -> SpeciesReference\n"
		"Reaction_getProduct(Reaction self, unsigned int n) -> SpeciesReference\n"
		"Reaction_getProduct(Reaction self, string species) -> SpeciesReference\n"
		"Reaction_getProduct(Reaction self, string species) -> SpeciesReference\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getProduct(string species)\n"
		"\n"
		"Returns the product species (as a SpeciesReference object) having  a\n"
		"specific identifier in this Reaction.\n"
		"\n"
		"Parameter 'species' is the identifier of the product Species\n"
		"('species' attribute of the product SpeciesReference object).\n"
		"\n"
		"Returns a SpeciesReference object, or 'None' if no species with the\n"
		"given identifier 'species' appears as a product in this Reaction.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getProduct(long n)\n"
		"\n"
		"Returns the nth product species (as a SpeciesReference object)  in the\n"
		"list of products in this Reaction.\n"
		"\n"
		"Callers should first call getNumProducts() to find out how many\n"
		"products there are, to avoid using an invalid index number.\n"
		"\n"
		"Parameter 'n' is the index of the product sought.\n"
		"\n"
		"Returns the nth product (as a SpeciesReference object) of this\n"
		"Reaction. If the index 'n' is invalid, 'None' is returned.\n"
		"\n"
		""},
	 { "Reaction_getModifier", _wrap_Reaction_getModifier, METH_VARARGS, "\n"
		"Reaction_getModifier(Reaction self, unsigned int n) -> ModifierSpeciesReference\n"
		"Reaction_getModifier(Reaction self, unsigned int n) -> ModifierSpeciesReference\n"
		"Reaction_getModifier(Reaction self, string species) -> ModifierSpeciesReference\n"
		"Reaction_getModifier(Reaction self, string species) -> ModifierSpeciesReference\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getModifier(string species)\n"
		"\n"
		"Returns the modifier species (as a ModifierSpeciesReference object)\n"
		"having a specific identifier in this Reaction.\n"
		"\n"
		"Parameter 'species' is the identifier of the modifier Species\n"
		"('species'  attribute of the ModifierSpeciesReference object).\n"
		"\n"
		"Returns a ModifierSpeciesReference object, or 'None' if no species\n"
		"with the given identifier 'species' appears as a modifier in this\n"
		"Reaction.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getModifier(long n)\n"
		"\n"
		"Returns the nth modifier species (as a ModifierSpeciesReference\n"
		"object)  in the list of modifiers of this Reaction.\n"
		"\n"
		"Callers should first call getNumModifiers() to find out how many\n"
		"modifiers there are, to avoid using an invalid index number.\n"
		"\n"
		"Parameter 'n' is the index of the modifier species sought.\n"
		"\n"
		"Returns the nth modifier (as a ModifierSpeciesReference object) of\n"
		"this Reaction. If the index 'n' is invalid, 'None' is returned.\n"
		"\n"
		""},
	 { "Reaction_getNumReactants", _wrap_Reaction_getNumReactants, METH_O, "\n"
		"Reaction_getNumReactants(Reaction self) -> unsigned int\n"
		"\n"
		"Returns the number of reactant species in this Reaction.\n"
		"\n"
		"Returns the number of reactants in this Reaction.\n"
		"\n"
		""},
	 { "Reaction_getNumProducts", _wrap_Reaction_getNumProducts, METH_O, "\n"
		"Reaction_getNumProducts(Reaction self) -> unsigned int\n"
		"\n"
		"Returns the number of product species in this Reaction.\n"
		"\n"
		"Returns the number of products in this Reaction.\n"
		"\n"
		""},
	 { "Reaction_getNumModifiers", _wrap_Reaction_getNumModifiers, METH_O, "\n"
		"Reaction_getNumModifiers(Reaction self) -> unsigned int\n"
		"\n"
		"Returns the number of modifier species in this Reaction.\n"
		"\n"
		"Returns the number of modifiers in this Reaction.\n"
		"\n"
		""},
	 { "Reaction_removeReactant", _wrap_Reaction_removeReactant, METH_VARARGS, "\n"
		"Reaction_removeReactant(Reaction self, unsigned int n) -> SpeciesReference\n"
		"Reaction_removeReactant(Reaction self, string species) -> SpeciesReference\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeReactant(string species)\n"
		"\n"
		"Removes the reactant species (SpeciesReference object) having the\n"
		"given   'species' attribute in this Reaction and returns a pointer to\n"
		"it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'species' is the 'species' attribute of the reactant\n"
		"SpeciesReference  object.\n"
		"\n"
		"Returns the removed reactant SpeciesReference object, or 'None' if no\n"
		"reactant SpeciesReference object with the given 'species' attribute\n"
		"'species' exists in this Reaction.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeReactant(long n)\n"
		"\n"
		"Removes the nth reactant species (SpeciesReference object) in the list\n"
		"of  reactants in this Reaction and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it. The caller should first call getNumReactants() to find out how\n"
		"many reactants there are, to avoid using an invalid index number.\n"
		"\n"
		"Parameter 'n' is the index of the reactant SpeciesReference object to\n"
		"remove.\n"
		"\n"
		"Returns the removed reactant SpeciesReference object, or 'None' if the\n"
		"given index is out of range.\n"
		"\n"
		""},
	 { "Reaction_removeProduct", _wrap_Reaction_removeProduct, METH_VARARGS, "\n"
		"Reaction_removeProduct(Reaction self, unsigned int n) -> SpeciesReference\n"
		"Reaction_removeProduct(Reaction self, string species) -> SpeciesReference\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeProduct(string species)\n"
		"\n"
		"Removes the product species (SpeciesReference object) having the given\n"
		"'species' attribute in this Reaction and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'species' is the 'species' attribute of the product\n"
		"SpeciesReference  object.\n"
		"\n"
		"Returns the removed product SpeciesReference object, or 'None' if no\n"
		"product SpeciesReference object with the given 'species' attribute\n"
		"'species' exists in this Reaction.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeProduct(long n)\n"
		"\n"
		"Removes the nth product species (SpeciesReference object) in the list\n"
		"of  products in this Reaction and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it. The caller should first call getNumProducts() to find out how many\n"
		"products there are, to avoid using an invalid index number.\n"
		"\n"
		"Parameter 'n' is the index of the product SpeciesReference object to\n"
		"remove.\n"
		"\n"
		"Returns the removed product SpeciesReference object, or 'None' if the\n"
		"given index is out of range.\n"
		"\n"
		""},
	 { "Reaction_removeModifier", _wrap_Reaction_removeModifier, METH_VARARGS, "\n"
		"Reaction_removeModifier(Reaction self, unsigned int n) -> ModifierSpeciesReference\n"
		"Reaction_removeModifier(Reaction self, string species) -> ModifierSpeciesReference\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeModifier(string species)\n"
		"\n"
		"Removes the modifier species (ModifierSpeciesReference object) having\n"
		"the given 'species' attribute in this Reaction and returns a pointer\n"
		"to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'species' is the 'species' attribute of the\n"
		"ModifierSpeciesReference  object.\n"
		"\n"
		"Returns the removed ModifierSpeciesReference object, or 'None' if no\n"
		"ModifierSpeciesReference object with the given 'species' attribute\n"
		"'species' exists in this Reaction.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeModifier(long n)\n"
		"\n"
		"Removes the nth modifier species (ModifierSpeciesReference object) in\n"
		"the list of  modifiers in this Reaction and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it. The caller should first call getNumModifiers() to find out how\n"
		"many modifiers there are, to avoid using an invalid index number.\n"
		"\n"
		"Parameter 'n' is the index of the ModifierSpeciesReference object to\n"
		"remove.\n"
		"\n"
		"Returns the removed ModifierSpeciesReference object, or 'None' if the\n"
		"given index is out of range.\n"
		"\n"
		""},
	 { "Reaction_connectToChild", _wrap_Reaction_connectToChild, METH_O, "Reaction_connectToChild(Reaction self)"},
	 { "Reaction_enablePackageInternal", _wrap_Reaction_enablePackageInternal, METH_VARARGS, "\n"
		"Reaction_enablePackageInternal(Reaction self, string pkgURI, string pkgPrefix, bool flag)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Reaction_updateSBMLNamespace", _wrap_Reaction_updateSBMLNamespace, METH_VARARGS, "\n"
		"Reaction_updateSBMLNamespace(Reaction self, string package, unsigned int level, unsigned int version)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Reaction_getTypeCode", _wrap_Reaction_getTypeCode, METH_O, "\n"
		"Reaction_getTypeCode(Reaction self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_REACTION (default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "Reaction_getElementName", _wrap_Reaction_getElementName, METH_O, "\n"
		"Reaction_getElementName(Reaction self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for Reaction, is\n"
		"always ''reaction'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''reaction'.'\n"
		"\n"
		""},
	 { "Reaction_hasRequiredAttributes", _wrap_Reaction_hasRequiredAttributes, METH_O, "\n"
		"Reaction_hasRequiredAttributes(Reaction self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"Reaction object have been set.\n"
		"\n"
		"The required attributes for a Reaction object are:\n"
		"\n"
		"* 'id' (or 'name' in SBML Level 1)\n"
		"\n"
		"* 'fast' (in Level 3 Version 1 only, where it is defined as a\n"
		"required attribute)\n"
		"\n"
		"* 'reversible' (in Level 3 only, where it is defined as a required\n"
		"attribute)\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Reaction_swigregister", Reaction_swigregister, METH_O, NULL},
	 { "Reaction_swiginit", Reaction_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfReactions", _wrap_new_ListOfReactions, METH_VARARGS, "\n"
		"ListOfReactions(unsigned int level, unsigned int version)\n"
		"new_ListOfReactions(SBMLNamespaces sbmlns) -> ListOfReactions\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfReactions(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfReactions object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfReactions object to be\n"
		"created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfReactions(long level, long version)\n"
		"\n"
		"Creates a new ListOfReactions object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfReactions_clone", _wrap_ListOfReactions_clone, METH_O, "\n"
		"ListOfReactions_clone(ListOfReactions self) -> ListOfReactions\n"
		"\n"
		"Creates and returns a deep copy of this ListOfReactions object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfReactions object.\n"
		"\n"
		""},
	 { "ListOfReactions_getItemTypeCode", _wrap_ListOfReactions_getItemTypeCode, METH_O, "\n"
		"ListOfReactions_getItemTypeCode(ListOfReactions self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., Reaction objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for objects contained in this list:\n"
		"SBML_REACTION (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfReactions_getElementName", _wrap_ListOfReactions_getElementName, METH_O, "\n"
		"ListOfReactions_getElementName(ListOfReactions self) -> string\n"
		"\n"
		"Returns the XML element name of this object\n"
		"\n"
		"For ListOfReactions, the XML element name is ''listOfReactions'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfReactions'.'\n"
		"\n"
		""},
	 { "ListOfReactions_get", _wrap_ListOfReactions_get, METH_VARARGS, "\n"
		"ListOfReactions_get(ListOfReactions self, unsigned int n) -> Reaction\n"
		"ListOfReactions_get(ListOfReactions self, unsigned int n) -> Reaction\n"
		"ListOfReactions_get(ListOfReactions self, string sid) -> Reaction\n"
		"ListOfReactions_get(ListOfReactions self, string sid) -> Reaction\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Get a Reaction from the ListOfReactions.\n"
		"\n"
		"Parameter 'n' is the index number of the Reaction to get.\n"
		"\n"
		"Returns the nth Reaction in this ListOfReactions. If the index 'n' is\n"
		"invalid, 'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Get a Reaction from the ListOfReactions based on its identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier of the\n"
		"Reaction to get.\n"
		"\n"
		"Returns Reaction in this ListOfReactions with the given 'sid' or\n"
		"'None' if no such Reaction exists.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfReactions_remove", _wrap_ListOfReactions_remove, METH_VARARGS, "\n"
		"ListOfReactions_remove(ListOfReactions self, unsigned int n) -> Reaction\n"
		"ListOfReactions_remove(ListOfReactions self, string sid) -> Reaction\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfReactions items and returns a\n"
		"pointer to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes item in this ListOfReactions items with the given identifier.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"If none of the items in this list have the identifier 'sid', then None\n"
		"is returned.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  As mentioned above, the caller owns the\n"
		"returned item.\n"
		"\n"
		""},
	 { "delete_ListOfReactions", _wrap_delete_ListOfReactions, METH_O, "delete_ListOfReactions(ListOfReactions self)"},
	 { "ListOfReactions_swigregister", ListOfReactions_swigregister, METH_O, NULL},
	 { "ListOfReactions_swiginit", ListOfReactions_swiginit, METH_VARARGS, NULL},
	 { "delete_KineticLaw", _wrap_delete_KineticLaw, METH_O, "delete_KineticLaw(KineticLaw self)"},
	 { "new_KineticLaw", _wrap_new_KineticLaw, METH_VARARGS, "\n"
		"KineticLaw(unsigned int level, unsigned int version)\n"
		"KineticLaw(SBMLNamespaces sbmlns)\n"
		"new_KineticLaw(KineticLaw orig) -> KineticLaw\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    KineticLaw(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new KineticLaw using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    KineticLaw(long level, long version)\n"
		"\n"
		"Creates a new KineticLaw using the given SBML 'level' and 'version'\n"
		"values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"KineticLaw.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this KineticLaw.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    KineticLaw(KineticLaw orig)\n"
		"\n"
		"Copy constructor; creates a copy of this KineticLaw.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "KineticLaw_clone", _wrap_KineticLaw_clone, METH_O, "\n"
		"KineticLaw_clone(KineticLaw self) -> KineticLaw\n"
		"\n"
		"Creates and returns a deep copy of this KineticLaw object.\n"
		"\n"
		"Returns the (deep) copy of this KineticLaw object.\n"
		"\n"
		""},
	 { "KineticLaw_getElementBySId", _wrap_KineticLaw_getElementBySId, METH_VARARGS, "\n"
		"KineticLaw_getElementBySId(KineticLaw self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given 'id' in the\n"
		"model-wide SId namespace, or 'None' if no such object is found.\n"
		"\n"
		"Parameter 'id' is string representing the id of the object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'id'.\n"
		"\n"
		""},
	 { "KineticLaw_getElementByMetaId", _wrap_KineticLaw_getElementByMetaId, METH_VARARGS, "\n"
		"KineticLaw_getElementByMetaId(KineticLaw self, string metaid) -> SBase\n"
		"\n"
		"Returns the first child element it can find with the given 'metaid',\n"
		"or 'None' if no such object is found.\n"
		"\n"
		"Parameter 'metaid' is string representing the metaid of the object to\n"
		"find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'metaid'.\n"
		"\n"
		""},
	 { "KineticLaw_getFormula", _wrap_KineticLaw_getFormula, METH_O, "\n"
		"KineticLaw_getFormula(KineticLaw self) -> string\n"
		"\n"
		"Returns the mathematical formula for this KineticLaw object and return\n"
		"it as as a text string.\n"
		"\n"
		"This is fundamentally equivalent to getMath(). This variant is\n"
		"provided principally for compatibility compatibility with SBML Level\n"
		"1.\n"
		"\n"
		"Returns a string representing the formula of this KineticLaw.\n"
		"\n"
		"Note: SBML Level 1 uses a text-string format for mathematical\n"
		"formulas. SBML Level 2 uses MathML, an XML format for representing\n"
		"mathematical expressions.  LibSBML provides an Abstract Syntax Tree\n"
		"API for working with mathematical expressions; this API is more\n"
		"powerful than working with formulas directly in text form, and ASTs\n"
		"can be translated into either MathML or the text-string syntax.  The\n"
		"libSBML methods that accept text-string formulas directly (such as\n"
		"this constructor) are provided for SBML Level 1 compatibility, but\n"
		"developers are encouraged to use the AST mechanisms.\n"
		"\n"
		"See also getMath().\n"
		"\n"
		""},
	 { "KineticLaw_getMath", _wrap_KineticLaw_getMath, METH_O, "\n"
		"KineticLaw_getMath(KineticLaw self) -> ASTNode\n"
		"\n"
		"Returns the mathematical formula for this KineticLaw object and return\n"
		"it as as an AST.\n"
		"\n"
		"This is fundamentally equivalent to getFormula(). The latter is\n"
		"provided principally for compatibility compatibility with SBML Level\n"
		"1, which represented mathematical formulas in text-string form.\n"
		"\n"
		"Returns the ASTNode representation of the mathematical formula,  or\n"
		"'None' if the math is not set.\n"
		"\n"
		"See also getFormula().\n"
		"\n"
		""},
	 { "KineticLaw_getTimeUnits", _wrap_KineticLaw_getTimeUnits, METH_O, "\n"
		"KineticLaw_getTimeUnits(KineticLaw self) -> string\n"
		"\n"
		"(SBML Level 2 Version 1 only) Returns the value of the 'timeUnits'\n"
		"attribute of this KineticLaw object.\n"
		"\n"
		"Returns the 'timeUnits' attribute value.\n"
		"\n"
		"Note: The attributes 'timeUnits' and 'substanceUnits' are present only\n"
		"in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'\n"
		"and 'substanceUnits' attributes were removed.  For compatibility with\n"
		"new versions of SBML, users are cautioned to avoid these attributes.\n"
		"\n"
		""},
	 { "KineticLaw_getSubstanceUnits", _wrap_KineticLaw_getSubstanceUnits, METH_O, "\n"
		"KineticLaw_getSubstanceUnits(KineticLaw self) -> string\n"
		"\n"
		"(SBML Level 2 Version 1 only) Returns the value of the\n"
		"'substanceUnits' attribute of this KineticLaw object.\n"
		"\n"
		"Returns the 'substanceUnits' attribute value.\n"
		"\n"
		"Note: The attributes 'timeUnits' and 'substanceUnits' are present only\n"
		"in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'\n"
		"and 'substanceUnits' attributes were removed.  For compatibility with\n"
		"new versions of SBML, users are cautioned to avoid these attributes.\n"
		"\n"
		""},
	 { "KineticLaw_isSetFormula", _wrap_KineticLaw_isSetFormula, METH_O, "\n"
		"KineticLaw_isSetFormula(KineticLaw self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this KineticLaw's 'formula' attribute is\n"
		"set.\n"
		"\n"
		"This is functionally identical to the method isSetMath().  It is\n"
		"provided in order to mirror the parallel between getFormula() and\n"
		"getMath().\n"
		"\n"
		"Returns 'True' if the formula (meaning the 'math' subelement) of this\n"
		"KineticLaw is set, 'False' otherwise.\n"
		"\n"
		"Note: SBML Level 1 uses a text-string format for mathematical\n"
		"formulas. SBML Level 2 uses MathML, an XML format for representing\n"
		"mathematical expressions.  LibSBML provides an Abstract Syntax Tree\n"
		"API for working with mathematical expressions; this API is more\n"
		"powerful than working with formulas directly in text form, and ASTs\n"
		"can be translated into either MathML or the text-string syntax.  The\n"
		"libSBML methods that accept text-string formulas directly (such as\n"
		"this constructor) are provided for SBML Level 1 compatibility, but\n"
		"developers are encouraged to use the AST mechanisms.\n"
		"\n"
		"See also isSetMath().\n"
		"\n"
		""},
	 { "KineticLaw_isSetMath", _wrap_KineticLaw_isSetMath, METH_O, "\n"
		"KineticLaw_isSetMath(KineticLaw self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Kinetic's 'math' subelement is set.\n"
		"\n"
		"This is identical to the method isSetFormula(). It is provided in\n"
		"order to mirror the parallel between getFormula() and getMath().\n"
		"\n"
		"Returns 'True' if the formula (meaning the 'math' subelement) of this\n"
		"KineticLaw is set, 'False' otherwise.\n"
		"\n"
		"See also isSetFormula().\n"
		"\n"
		""},
	 { "KineticLaw_isSetTimeUnits", _wrap_KineticLaw_isSetTimeUnits, METH_O, "\n"
		"KineticLaw_isSetTimeUnits(KineticLaw self) -> bool\n"
		"\n"
		"(SBML Level 2 Version 1 only) Predicate returning 'True' if this\n"
		"SpeciesReference's 'timeUnits' attribute is set.\n"
		"\n"
		"Returns 'True' if the 'timeUnits' attribute of this KineticLaw object\n"
		"is set, 'False' otherwise.\n"
		"\n"
		"Note: The attributes 'timeUnits' and 'substanceUnits' are present only\n"
		"in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'\n"
		"and 'substanceUnits' attributes were removed.  For compatibility with\n"
		"new versions of SBML, users are cautioned to avoid these attributes.\n"
		"\n"
		""},
	 { "KineticLaw_isSetSubstanceUnits", _wrap_KineticLaw_isSetSubstanceUnits, METH_O, "\n"
		"KineticLaw_isSetSubstanceUnits(KineticLaw self) -> bool\n"
		"\n"
		"(SBML Level 2 Version 1 only) Predicate returning 'True' if this\n"
		"SpeciesReference's 'substanceUnits' attribute is set.\n"
		"\n"
		"Returns 'True' if the 'substanceUnits' attribute of this KineticLaw\n"
		"object is set, 'False' otherwise.\n"
		"\n"
		"Note: The attributes 'timeUnits' and 'substanceUnits' are present only\n"
		"in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'\n"
		"and 'substanceUnits' attributes were removed.  For compatibility with\n"
		"new versions of SBML, users are cautioned to avoid these attributes.\n"
		"\n"
		""},
	 { "KineticLaw_setFormula", _wrap_KineticLaw_setFormula, METH_VARARGS, "\n"
		"KineticLaw_setFormula(KineticLaw self, string formula) -> int\n"
		"\n"
		"Sets the mathematical expression of this KineticLaw instance to the\n"
		"given 'formula'.\n"
		"\n"
		"The given 'formula' string is copied.  Internally, libSBML stores the\n"
		"mathematical expression as an ASTNode.\n"
		"\n"
		"Parameter 'formula' is the mathematical expression to use, represented\n"
		"in text-string form.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"Note: SBML Level 1 uses a text-string format for mathematical\n"
		"formulas. SBML Level 2 uses MathML, an XML format for representing\n"
		"mathematical expressions.  LibSBML provides an Abstract Syntax Tree\n"
		"API for working with mathematical expressions; this API is more\n"
		"powerful than working with formulas directly in text form, and ASTs\n"
		"can be translated into either MathML or the text-string syntax.  The\n"
		"libSBML methods that accept text-string formulas directly (such as\n"
		"this constructor) are provided for SBML Level 1 compatibility, but\n"
		"developers are encouraged to use the AST mechanisms.\n"
		"\n"
		"See also setMath().\n"
		"\n"
		""},
	 { "KineticLaw_setMath", _wrap_KineticLaw_setMath, METH_VARARGS, "\n"
		"KineticLaw_setMath(KineticLaw self, ASTNode math) -> int\n"
		"\n"
		"Sets the mathematical expression of this KineticLaw instance to a copy\n"
		"of the given ASTNode.\n"
		"\n"
		"This is fundamentally identical to getFormula(). The latter is\n"
		"provided principally for compatibility compatibility with SBML Level\n"
		"1, which represented mathematical formulas in text-string form.\n"
		"\n"
		"Parameter 'math' is an ASTNode representing a formula tree.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"See also setFormula().\n"
		"\n"
		""},
	 { "KineticLaw_setTimeUnits", _wrap_KineticLaw_setTimeUnits, METH_VARARGS, "\n"
		"KineticLaw_setTimeUnits(KineticLaw self, string sid) -> int\n"
		"\n"
		"(SBML Level 2 Version 1 only) Sets the 'timeUnits' attribute of this\n"
		"KineticLaw object to a copy of the identifier in 'sid'.\n"
		"\n"
		"Parameter 'sid' is the identifier of the units to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The attributes 'timeUnits' and 'substanceUnits' are present only\n"
		"in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'\n"
		"and 'substanceUnits' attributes were removed.  For compatibility with\n"
		"new versions of SBML, users are cautioned to avoid these attributes.\n"
		"\n"
		""},
	 { "KineticLaw_setSubstanceUnits", _wrap_KineticLaw_setSubstanceUnits, METH_VARARGS, "\n"
		"KineticLaw_setSubstanceUnits(KineticLaw self, string sid) -> int\n"
		"\n"
		"(SBML Level 2 Version 1 only) Sets the 'substanceUnits' attribute of\n"
		"this KineticLaw object to a copy of the identifier given in 'sid'.\n"
		"\n"
		"Parameter 'sid' is the identifier of the units to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The attributes 'timeUnits' and 'substanceUnits' are present only\n"
		"in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'\n"
		"and 'substanceUnits' attributes were removed.  For compatibility with\n"
		"new versions of SBML, users are cautioned to avoid these attributes.\n"
		"\n"
		""},
	 { "KineticLaw_unsetTimeUnits", _wrap_KineticLaw_unsetTimeUnits, METH_O, "\n"
		"KineticLaw_unsetTimeUnits(KineticLaw self) -> int\n"
		"\n"
		"(SBML Level 2 Version 1 only) Unsets the 'timeUnits' attribugte of\n"
		"this KineticLaw object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The attributes 'timeUnits' and 'substanceUnits' are present only\n"
		"in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'\n"
		"and 'substanceUnits' attributes were removed.  For compatibility with\n"
		"new versions of SBML, users are cautioned to avoid these attributes.\n"
		"\n"
		""},
	 { "KineticLaw_unsetSubstanceUnits", _wrap_KineticLaw_unsetSubstanceUnits, METH_O, "\n"
		"KineticLaw_unsetSubstanceUnits(KineticLaw self) -> int\n"
		"\n"
		"(SBML Level 2 Version 1 only) Unsets the 'substanceUnits' attribute of\n"
		"this KineticLaw object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The attributes 'timeUnits' and 'substanceUnits' are present only\n"
		"in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'\n"
		"and 'substanceUnits' attributes were removed.  For compatibility with\n"
		"new versions of SBML, users are cautioned to avoid these attributes.\n"
		"\n"
		""},
	 { "KineticLaw_addParameter", _wrap_KineticLaw_addParameter, METH_VARARGS, "\n"
		"KineticLaw_addParameter(KineticLaw self, Parameter p) -> int\n"
		"\n"
		"Adds a copy of the given Parameter object to the list of local\n"
		"parameters in this KineticLaw.\n"
		"\n"
		"This function should be used for SBML Level 1 and Level 2 documents,\n"
		"as the equivalent constructs in Level 3 are LocalParameter objects\n"
		"instead.\n"
		"\n"
		"Parameter 'p' is the Parameter to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createParameter().\n"
		"\n"
		""},
	 { "KineticLaw_addLocalParameter", _wrap_KineticLaw_addLocalParameter, METH_VARARGS, "\n"
		"KineticLaw_addLocalParameter(KineticLaw self, LocalParameter p) -> int\n"
		"\n"
		"Adds a copy of the given LocalParameter object to the list of local\n"
		"parameters in this KineticLaw.\n"
		"\n"
		"This function should be used for SBML Level 3 documents, as the\n"
		"equivalent  constructs in Level 2 and Level 1 are Parameter objects\n"
		"instead.\n"
		"\n"
		"Parameter 'p' is the LocalParameter to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createLocalParameter().\n"
		"\n"
		""},
	 { "KineticLaw_createParameter", _wrap_KineticLaw_createParameter, METH_O, "\n"
		"KineticLaw_createParameter(KineticLaw self) -> Parameter\n"
		"\n"
		"Creates a new Parameter object, adds it to this KineticLaw's list of\n"
		"parameters, and returns the Parameter object created.\n"
		"\n"
		"This function should be used for SBML Level 1 and Level 2 documents,\n"
		"as the equivalent constructs in Level 3 are LocalParameter objects\n"
		"instead.\n"
		"\n"
		"Returns a new Parameter object instance.\n"
		"\n"
		"See also addParameter().\n"
		"\n"
		""},
	 { "KineticLaw_createLocalParameter", _wrap_KineticLaw_createLocalParameter, METH_O, "\n"
		"KineticLaw_createLocalParameter(KineticLaw self) -> LocalParameter\n"
		"\n"
		"Creates a new LocalParameter object, adds it to this KineticLaw's list\n"
		"of local parameters, and returns the LocalParameter object created.\n"
		"\n"
		"This function should be used for SBML Level 3 documents, as the\n"
		"equivalent  constructs in Level 2 and Level 1 are Parameter objects\n"
		"instead.\n"
		"\n"
		"Returns a new LocalParameter object instance.\n"
		"\n"
		"See also addLocalParameter().\n"
		"\n"
		""},
	 { "KineticLaw_getListOfParameters", _wrap_KineticLaw_getListOfParameters, METH_VARARGS, "\n"
		"KineticLaw_getListOfParameters(KineticLaw self) -> ListOfParameters\n"
		"KineticLaw_getListOfParameters(KineticLaw self) -> ListOfParameters\n"
		"\n"
		"Returns the list of parameters in this KineticLaw object.\n"
		"\n"
		"This function should be used for SBML Level 1 and Level 2 documents,\n"
		"as the equivalent constructs in Level 3 are LocalParameter objects\n"
		"instead.\n"
		"\n"
		"Returns the list of Parameters for this KineticLaw.\n"
		"\n"
		""},
	 { "KineticLaw_getListOfLocalParameters", _wrap_KineticLaw_getListOfLocalParameters, METH_VARARGS, "\n"
		"KineticLaw_getListOfLocalParameters(KineticLaw self) -> ListOfLocalParameters\n"
		"KineticLaw_getListOfLocalParameters(KineticLaw self) -> ListOfLocalParameters\n"
		"\n"
		"Returns the list of local parameters in this KineticLaw object.\n"
		"\n"
		"This function should be used for SBML Level 3 documents, as the\n"
		"equivalent  constructs in Level 2 and Level 1 are Parameter objects\n"
		"instead.\n"
		"\n"
		"Returns the list of LocalParameters for this KineticLaw.\n"
		"\n"
		""},
	 { "KineticLaw_getParameter", _wrap_KineticLaw_getParameter, METH_VARARGS, "\n"
		"KineticLaw_getParameter(KineticLaw self, unsigned int n) -> Parameter\n"
		"KineticLaw_getParameter(KineticLaw self, unsigned int n) -> Parameter\n"
		"KineticLaw_getParameter(KineticLaw self, string sid) -> Parameter\n"
		"KineticLaw_getParameter(KineticLaw self, string sid) -> Parameter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getParameter(long n)\n"
		"\n"
		"Returns the nth Parameter object in the list of parameters in this\n"
		"KineticLaw instance.\n"
		"\n"
		"This function should be used for SBML Level 1 and Level 2 documents,\n"
		"as the equivalent constructs in Level 3 are LocalParameter objects\n"
		"instead.\n"
		"\n"
		"Parameter 'n' is the index of the Parameter object sought.\n"
		"\n"
		"Returns the nth Parameter of this KineticLaw. If the index 'n' is\n"
		"invalid, 'None' is returned.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getParameter(string sid)\n"
		"\n"
		"Returns a parameter based on its identifier.\n"
		"\n"
		"This function should be used for SBML Level 1 and Level 2 documents,\n"
		"as the equivalent constructs in Level 3 are LocalParameter objects\n"
		"instead.\n"
		"\n"
		"Parameter 'sid' is the identifier of the Parameter being sought.\n"
		"\n"
		"Returns the Parameter object in this KineticLaw instace having the\n"
		"given 'id', or 'None' if no such Parameter exists.\n"
		"\n"
		""},
	 { "KineticLaw_getLocalParameter", _wrap_KineticLaw_getLocalParameter, METH_VARARGS, "\n"
		"KineticLaw_getLocalParameter(KineticLaw self, unsigned int n) -> LocalParameter\n"
		"KineticLaw_getLocalParameter(KineticLaw self, unsigned int n) -> LocalParameter\n"
		"KineticLaw_getLocalParameter(KineticLaw self, string sid) -> LocalParameter\n"
		"KineticLaw_getLocalParameter(KineticLaw self, string sid) -> LocalParameter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getLocalParameter(long n)\n"
		"\n"
		"Returns the nth LocalParameter object in the list of local parameters\n"
		"in this KineticLaw instance.\n"
		"\n"
		"This function should be used for SBML Level 3 documents, as the\n"
		"equivalent  constructs in Level 2 and Level 1 are Parameter objects\n"
		"instead.\n"
		"\n"
		"Parameter 'n' is the index of the LocalParameter object sought.\n"
		"\n"
		"Returns the nth LocalParameter of this KineticLaw. If the index 'n' is\n"
		"invalid, 'None' is returned.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getLocalParameter(string sid)\n"
		"\n"
		"Returns a local parameter based on its identifier.\n"
		"\n"
		"This function should be used for SBML Level 3 documents, as the\n"
		"equivalent  constructs in Level 2 and Level 1 are Parameter objects\n"
		"instead.\n"
		"\n"
		"Parameter 'sid' is the identifier of the LocalParameter being sought.\n"
		"\n"
		"Returns the LocalParameter object in this KineticLaw instace having\n"
		"the given 'id', or 'None' if no such LocalParameter exists.\n"
		"\n"
		""},
	 { "KineticLaw_getNumParameters", _wrap_KineticLaw_getNumParameters, METH_O, "\n"
		"KineticLaw_getNumParameters(KineticLaw self) -> unsigned int\n"
		"\n"
		"Returns the number of parameters in this KineticLaw instance.\n"
		"\n"
		"This function should be used for SBML Level 1 and Level 2 documents,\n"
		"as the equivalent constructs in Level 3 are LocalParameter objects\n"
		"instead.\n"
		"\n"
		"Returns the number of Parameters in this KineticLaw.\n"
		"\n"
		""},
	 { "KineticLaw_getNumLocalParameters", _wrap_KineticLaw_getNumLocalParameters, METH_O, "\n"
		"KineticLaw_getNumLocalParameters(KineticLaw self) -> unsigned int\n"
		"\n"
		"Returns the number of local parameters in this KineticLaw instance.\n"
		"\n"
		"This function should be used for SBML Level 3 documents, as the\n"
		"equivalent  constructs in Level 2 and Level 1 are Parameter objects\n"
		"instead.\n"
		"\n"
		"Returns the number of LocalParameters in this KineticLaw.\n"
		"\n"
		""},
	 { "KineticLaw_getDerivedUnitDefinition", _wrap_KineticLaw_getDerivedUnitDefinition, METH_VARARGS, "\n"
		"KineticLaw_getDerivedUnitDefinition(KineticLaw self) -> UnitDefinition\n"
		"KineticLaw_getDerivedUnitDefinition(KineticLaw self) -> UnitDefinition\n"
		"\n"
		"Calculates and returns a UnitDefinition that expresses the units of\n"
		"measurement assumed for the 'math' expression of this KineticLaw.\n"
		"\n"
		"The units are calculated based on the mathematical expression in the\n"
		"KineticLaw and the model quantities referenced by <ci> elements used\n"
		"within that expression.  The getDerivedUnitDefinition() method returns\n"
		"the calculated units.\n"
		"\n"
		"Note: The functionality that facilitates unit analysis depends on the\n"
		"model as a whole.  Thus, in cases where the object has not been added\n"
		"to a model or the model itself is incomplete, unit analysis is not\n"
		"possible and this method will return 'None.'\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Note that it is possible the 'math' expression in the KineticLaw\n"
		"contains pure numbers or parameters with undeclared units.  In those\n"
		"cases, it is not possible to calculate the units of the overall\n"
		"expression without making assumptions.  LibSBML does not make\n"
		"assumptions about the units, and KineticLaw.getDerivedUnitDefinition()\n"
		"returns the units as far as it is able to determine them.  For\n"
		"example, in an expression X + Y, if X has unambiguously-defined units\n"
		"and Y does not, it will return the units of X.  It is important that\n"
		"callers also invoke the method KineticLaw.containsUndeclaredUnits()to\n"
		"determine whether this situation holds.  Callers may wish to take\n"
		"suitable actions in those scenarios.\n"
		"\n"
		"Returns a UnitDefinition that expresses the units of the math\n"
		"expression of this KineticLaw, or 'None' if one cannot be constructed.\n"
		"\n"
		"See also containsUndeclaredUnits().\n"
		"\n"
		""},
	 { "KineticLaw_containsUndeclaredUnits", _wrap_KineticLaw_containsUndeclaredUnits, METH_VARARGS, "\n"
		"KineticLaw_containsUndeclaredUnits(KineticLaw self) -> bool\n"
		"KineticLaw_containsUndeclaredUnits(KineticLaw self) -> bool\n"
		"\n"
		"Predicate returning 'True' if the math expression of this KineticLaw\n"
		"contains parameters/numbers with undeclared units.\n"
		"\n"
		"Returns 'True' if the math expression of this KineticLaw includes\n"
		"parameters/numbers  with undeclared units, 'False' otherwise.\n"
		"\n"
		"Note: A return value of 'True' indicates that the UnitDefinition\n"
		"returned by getDerivedUnitDefinition() may not accurately represent\n"
		"the units of the expression.\n"
		"\n"
		"See also getDerivedUnitDefinition().\n"
		"\n"
		""},
	 { "KineticLaw_removeParameter", _wrap_KineticLaw_removeParameter, METH_VARARGS, "\n"
		"KineticLaw_removeParameter(KineticLaw self, unsigned int n) -> Parameter\n"
		"KineticLaw_removeParameter(KineticLaw self, string sid) -> Parameter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeParameter(long n)\n"
		"\n"
		"Removes the nth Parameter object in the list of parameters  in this\n"
		"KineticLaw instance and returns a pointer to it.\n"
		"\n"
		"This function should be used for SBML Level 1 and Level 2 documents,\n"
		"as the equivalent constructs in Level 3 are LocalParameter objects\n"
		"instead.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the Parameter object to remove.\n"
		"\n"
		"Returns the Parameter object removed.  As mentioned above,  the caller\n"
		"owns the returned item. 'None' is returned if the given index  is out\n"
		"of range.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeParameter(string sid)\n"
		"\n"
		"Removes a Parameter object with the given identifier in the list of\n"
		"parameters in this KineticLaw instance and returns a pointer to it.\n"
		"\n"
		"This function should be used for SBML Level 1 and Level 2 documents,\n"
		"as the equivalent constructs in Level 3 are LocalParameter objects\n"
		"instead.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the Parameter to remove.\n"
		"\n"
		"Returns the Parameter object removed.  As mentioned above, the  caller\n"
		"owns the returned object. 'None' is returned if no Parameter object\n"
		"with the identifier exists in this KineticLaw instance.\n"
		"\n"
		""},
	 { "KineticLaw_removeLocalParameter", _wrap_KineticLaw_removeLocalParameter, METH_VARARGS, "\n"
		"KineticLaw_removeLocalParameter(KineticLaw self, unsigned int n) -> LocalParameter\n"
		"KineticLaw_removeLocalParameter(KineticLaw self, string sid) -> LocalParameter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeLocalParameter(long n)\n"
		"\n"
		"Removes the nth LocalParameter object in the list of local parameters\n"
		"in this KineticLaw instance and returns a pointer to it.\n"
		"\n"
		"This function should be used for SBML Level 3 documents, as the\n"
		"equivalent  constructs in Level 2 and Level 1 are Parameter objects\n"
		"instead.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the LocalParameter object to remove.\n"
		"\n"
		"Returns the LocalParameter object removed.  As mentioned above,  the\n"
		"caller owns the returned item. 'None' is returned if the given index\n"
		"is out of range.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeLocalParameter(string sid)\n"
		"\n"
		"Removes a LocalParameter object with the given identifier in the list\n"
		"of local parameters in this KineticLaw instance and returns a pointer\n"
		"to it.\n"
		"\n"
		"This function should be used for SBML Level 3 documents, as the\n"
		"equivalent  constructs in Level 2 and Level 1 are Parameter objects\n"
		"instead.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'sid' is the identifier of the LocalParameter to remove.\n"
		"\n"
		"Returns the LocalParameter object removed.  As mentioned above, the\n"
		"caller owns the returned object. 'None' is returned if no\n"
		"LocalParameter object with the identifier exists in this KineticLaw\n"
		"instance.\n"
		"\n"
		""},
	 { "KineticLaw_connectToChild", _wrap_KineticLaw_connectToChild, METH_O, "KineticLaw_connectToChild(KineticLaw self)"},
	 { "KineticLaw_enablePackageInternal", _wrap_KineticLaw_enablePackageInternal, METH_VARARGS, "\n"
		"KineticLaw_enablePackageInternal(KineticLaw self, string pkgURI, string pkgPrefix, bool flag)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "KineticLaw_updateSBMLNamespace", _wrap_KineticLaw_updateSBMLNamespace, METH_VARARGS, "\n"
		"KineticLaw_updateSBMLNamespace(KineticLaw self, string package, unsigned int level, unsigned int version)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "KineticLaw_getTypeCode", _wrap_KineticLaw_getTypeCode, METH_O, "\n"
		"KineticLaw_getTypeCode(KineticLaw self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_KINETIC_LAW\n"
		"(default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "KineticLaw_getElementName", _wrap_KineticLaw_getElementName, METH_O, "\n"
		"KineticLaw_getElementName(KineticLaw self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for Species, is\n"
		"always ''kineticLaw'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''kineticLaw'.'\n"
		"\n"
		""},
	 { "KineticLaw_hasRequiredAttributes", _wrap_KineticLaw_hasRequiredAttributes, METH_O, "\n"
		"KineticLaw_hasRequiredAttributes(KineticLaw self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"KineticLaw object have been set.\n"
		"\n"
		"The required attributes for a KineticLaw object are:\n"
		"\n"
		"* 'formula' (SBML Level 1 only)\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "KineticLaw_hasRequiredElements", _wrap_KineticLaw_hasRequiredElements, METH_O, "\n"
		"KineticLaw_hasRequiredElements(KineticLaw self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this\n"
		"KineticLaw object have been set.\n"
		"\n"
		"Note: The required elements for a KineticLaw object are:\n"
		"\n"
		"* 'math' inSBML Level 2 and Level 3 Version 1.   (In SBML Level 3\n"
		"Version 2+, it is no longer required.)\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "KineticLaw_removeFromParentAndDelete", _wrap_KineticLaw_removeFromParentAndDelete, METH_O, "\n"
		"KineticLaw_removeFromParentAndDelete(KineticLaw self) -> int\n"
		"\n"
		"Finds this KineticLaw's Reaction parent and calls unsetKineticLaw() on\n"
		"it, indirectly deleting itself.\n"
		"\n"
		"Overridden from the SBase function since the parent is not a ListOf.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "KineticLaw_renameSIdRefs", _wrap_KineticLaw_renameSIdRefs, METH_VARARGS, "\n"
		"KineticLaw_renameSIdRefs(KineticLaw self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "KineticLaw_renameUnitSIdRefs", _wrap_KineticLaw_renameUnitSIdRefs, METH_VARARGS, "\n"
		"KineticLaw_renameUnitSIdRefs(KineticLaw self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "KineticLaw_replaceSIDWithFunction", _wrap_KineticLaw_replaceSIDWithFunction, METH_VARARGS, "\n"
		"KineticLaw_replaceSIDWithFunction(KineticLaw self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "KineticLaw_divideAssignmentsToSIdByFunction", _wrap_KineticLaw_divideAssignmentsToSIdByFunction, METH_VARARGS, "\n"
		"KineticLaw_divideAssignmentsToSIdByFunction(KineticLaw self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "KineticLaw_multiplyAssignmentsToSIdByFunction", _wrap_KineticLaw_multiplyAssignmentsToSIdByFunction, METH_VARARGS, "\n"
		"KineticLaw_multiplyAssignmentsToSIdByFunction(KineticLaw self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "KineticLaw_swigregister", KineticLaw_swigregister, METH_O, NULL},
	 { "KineticLaw_swiginit", KineticLaw_swiginit, METH_VARARGS, NULL},
	 { "delete_SimpleSpeciesReference", _wrap_delete_SimpleSpeciesReference, METH_O, "delete_SimpleSpeciesReference(SimpleSpeciesReference self)"},
	 { "SimpleSpeciesReference_getId", _wrap_SimpleSpeciesReference_getId, METH_O, "\n"
		"SimpleSpeciesReference_getId(SimpleSpeciesReference self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this\n"
		"SimpleSpeciesReference.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() function instead.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this SimpleSpeciesReference.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_getName", _wrap_SimpleSpeciesReference_getName, METH_O, "\n"
		"SimpleSpeciesReference_getName(SimpleSpeciesReference self) -> string\n"
		"\n"
		"Returns the value of the 'name' attribute of this\n"
		"SimpleSpeciesReference object.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns the name of this SBML object, or the empty string if not set\n"
		"or unsettable.\n"
		"\n"
		"See also getIdAttribute(), isSetName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_getSpecies", _wrap_SimpleSpeciesReference_getSpecies, METH_O, "\n"
		"SimpleSpeciesReference_getSpecies(SimpleSpeciesReference self) -> string\n"
		"\n"
		"Get the value of the 'species' attribute.\n"
		"\n"
		"Returns the value of the attribute 'species' for this\n"
		"SimpleSpeciesReference.\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_isSetId", _wrap_SimpleSpeciesReference_isSetId, METH_O, "\n"
		"SimpleSpeciesReference_isSetId(SimpleSpeciesReference self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this SimpleSpeciesReference's 'id'\n"
		"attribute is set.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is recommended that callers use\n"
		"isSetIdAttribute() instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),\n"
		"isSetIdAttribute().\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_isSetName", _wrap_SimpleSpeciesReference_isSetName, METH_O, "\n"
		"SimpleSpeciesReference_isSetName(SimpleSpeciesReference self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this SimpleSpeciesReference's 'name'\n"
		"attribute is set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns 'True' if the 'name' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_isSetSpecies", _wrap_SimpleSpeciesReference_isSetSpecies, METH_O, "\n"
		"SimpleSpeciesReference_isSetSpecies(SimpleSpeciesReference self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this SimpleSpeciesReference's 'species'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'species' attribute of this\n"
		"SimpleSpeciesReference is set, 'False' otherwise.\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_setSpecies", _wrap_SimpleSpeciesReference_setSpecies, METH_VARARGS, "\n"
		"SimpleSpeciesReference_setSpecies(SimpleSpeciesReference self, string sid) -> int\n"
		"\n"
		"Sets the 'species' attribute of this SimpleSpeciesReference.\n"
		"\n"
		"The identifier string passed in 'sid' is copied.\n"
		"\n"
		"Parameter 'sid' is the identifier of a species defined in the\n"
		"enclosing Model's ListOfSpecies.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_setId", _wrap_SimpleSpeciesReference_setId, METH_VARARGS, "\n"
		"SimpleSpeciesReference_setId(SimpleSpeciesReference self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this SimpleSpeciesReference.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_setName", _wrap_SimpleSpeciesReference_setName, METH_VARARGS, "\n"
		"SimpleSpeciesReference_setName(SimpleSpeciesReference self, string name) -> int\n"
		"\n"
		"Sets the value of the 'name' attribute of this SimpleSpeciesReference.\n"
		"\n"
		"The string in 'name' is copied.\n"
		"\n"
		"Parameter 'name' is the new name for the SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_unsetId", _wrap_SimpleSpeciesReference_unsetId, METH_O, "\n"
		"SimpleSpeciesReference_unsetId(SimpleSpeciesReference self) -> int\n"
		"\n"
		"Unsets the value of the 'id' attribute of this SimpleSpeciesReference.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_unsetName", _wrap_SimpleSpeciesReference_unsetName, METH_O, "\n"
		"SimpleSpeciesReference_unsetName(SimpleSpeciesReference self) -> int\n"
		"\n"
		"Unsets the value of the 'name' attribute of this\n"
		"SimpleSpeciesReference.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getName(), setName(), isSetName().\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_unsetSpecies", _wrap_SimpleSpeciesReference_unsetSpecies, METH_O, "\n"
		"SimpleSpeciesReference_unsetSpecies(SimpleSpeciesReference self) -> int\n"
		"\n"
		"Unsets the value of the 'species' attribute of this\n"
		"SimpleSpeciesReference.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_isModifier", _wrap_SimpleSpeciesReference_isModifier, METH_O, "\n"
		"SimpleSpeciesReference_isModifier(SimpleSpeciesReference self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this is a ModifierSpeciesReference.\n"
		"\n"
		"Returns 'True' if this SimpleSpeciesReference's subclass is\n"
		"ModiferSpeciesReference, 'False' if it is a plain SpeciesReference.\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_renameSIdRefs", _wrap_SimpleSpeciesReference_renameSIdRefs, METH_VARARGS, "\n"
		"SimpleSpeciesReference_renameSIdRefs(SimpleSpeciesReference self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "SimpleSpeciesReference_swigregister", SimpleSpeciesReference_swigregister, METH_O, NULL},
	 { "delete_SpeciesReference", _wrap_delete_SpeciesReference, METH_O, "delete_SpeciesReference(SpeciesReference self)"},
	 { "new_SpeciesReference", _wrap_new_SpeciesReference, METH_VARARGS, "\n"
		"SpeciesReference(unsigned int level, unsigned int version)\n"
		"SpeciesReference(SBMLNamespaces sbmlns)\n"
		"new_SpeciesReference(SpeciesReference orig) -> SpeciesReference\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SpeciesReference(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new SpeciesReference using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SpeciesReference(long level, long version)\n"
		"\n"
		"Creates a new SpeciesReference using the given SBML 'level' and\n"
		"'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"SpeciesReference.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this SpeciesReference.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SpeciesReference(SpeciesReference orig)\n"
		"\n"
		"Copy constructor; creates a copy of this SpeciesReference.\n"
		"\n"
		"Parameter 'orig' is the SpeciesReference instance to copy.\n"
		"\n"
		""},
	 { "SpeciesReference_clone", _wrap_SpeciesReference_clone, METH_O, "\n"
		"SpeciesReference_clone(SpeciesReference self) -> SpeciesReference\n"
		"\n"
		"Creates and returns a deep copy of this SpeciesReference object.\n"
		"\n"
		"Returns the (deep) copy of this SpeciesReference object.\n"
		"\n"
		""},
	 { "SpeciesReference_initDefaults", _wrap_SpeciesReference_initDefaults, METH_O, "\n"
		"SpeciesReference_initDefaults(SpeciesReference self)\n"
		"\n"
		"Initializes the fields of this SpeciesReference object to 'typical'\n"
		"default values.\n"
		"\n"
		"The SBML SpeciesReference component has slightly different aspects and\n"
		"default attribute values in different SBML Levels and Versions. This\n"
		"method sets the values to certain common defaults, based mostly on\n"
		"what they are in SBML Level 2.  Specifically:\n"
		"\n"
		"* Sets attribute 'stoichiometry' to '1.0'\n"
		"\n"
		"* (Applies to Level 1 models only) Sets attribute 'denominator' to\n"
		"'1' See also getDenominator(), setDenominator(), getStoichiometry(),\n"
		"setStoichiometry(), getStoichiometryMath(), setStoichiometryMath().\n"
		"\n"
		""},
	 { "SpeciesReference_getStoichiometry", _wrap_SpeciesReference_getStoichiometry, METH_O, "\n"
		"SpeciesReference_getStoichiometry(SpeciesReference self) -> double\n"
		"\n"
		"Get the value of the 'stoichiometry' attribute.\n"
		"\n"
		"In SBML Level 2, product and reactant stoichiometries can be specified\n"
		"using either 'stoichiometry' or 'stoichiometryMath' in a\n"
		"SpeciesReference object.  The former is to be used when a\n"
		"stoichiometry is simply a scalar number, while the latter is for\n"
		"occasions when it needs to be a rational number or it needs to\n"
		"reference other mathematical expressions.  The 'stoichiometry'\n"
		"attribute is of type 'float' and should contain values greater than\n"
		"zero ('0).'  The 'stoichiometryMath' element is implemented as an\n"
		"element containing a MathML expression.  These two are mutually\n"
		"exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should\n"
		"be defined in a given SpeciesReference instance.  When neither the\n"
		"attribute nor the element is present, the value of 'stoichiometry' in\n"
		"the SpeciesReference instance defaults to '1.'  For maximum\n"
		"interoperability between different software tools, the 'stoichiometry'\n"
		"attribute should be used in preference to 'stoichiometryMath' when a\n"
		"species' stoichiometry is a simple scalar number (integer or decimal).\n"
		"\n"
		"In SBML Level 3, there is no StoichiometryMath, and SpeciesReference\n"
		"objects have only the 'stoichiometry' attribute.\n"
		"\n"
		"Returns the value of the (scalar) 'stoichiometry' attribute of this\n"
		"SpeciesReference.\n"
		"\n"
		"See also getStoichiometryMath().\n"
		"\n"
		""},
	 { "SpeciesReference_getStoichiometryMath", _wrap_SpeciesReference_getStoichiometryMath, METH_VARARGS, "\n"
		"SpeciesReference_getStoichiometryMath(SpeciesReference self) -> StoichiometryMath\n"
		"SpeciesReference_getStoichiometryMath(SpeciesReference self) -> StoichiometryMath\n"
		"\n"
		"Get the content of the 'stoichiometryMath' subelement as an ASTNode\n"
		"tree.\n"
		"\n"
		"The 'stoichiometryMath' element exists only in SBML Level 2.  There,\n"
		"product and reactant stoichiometries can be specified using either\n"
		"'stoichiometry' or 'stoichiometryMath' in a SpeciesReference object.\n"
		"The former is to be used when a stoichiometry is simply a scalar\n"
		"number, while the latter is for occasions when it needs to be a\n"
		"rational number or it needs to reference other mathematical\n"
		"expressions.  The 'stoichiometry' attribute is of type 'float' and\n"
		"should contain values greater than zero ('0).'  The\n"
		"'stoichiometryMath' element is implemented as an element containing a\n"
		"MathML expression.  These two are mutually exclusive; only one of\n"
		"'stoichiometry' or 'stoichiometryMath' should be defined in a given\n"
		"SpeciesReference instance.  When neither the attribute nor the element\n"
		"is present, the value of 'stoichiometry' in the SpeciesReference\n"
		"instance defaults to '1.'  For maximum interoperability between\n"
		"different software tools, the 'stoichiometry' attribute should be used\n"
		"in preference to 'stoichiometryMath' when a species' stoichiometry is\n"
		"a simple scalar number (integer or decimal).\n"
		"\n"
		"Returns the content of the 'stoichiometryMath' subelement of this\n"
		"SpeciesReference.\n"
		"\n"
		""},
	 { "SpeciesReference_getDenominator", _wrap_SpeciesReference_getDenominator, METH_O, "\n"
		"SpeciesReference_getDenominator(SpeciesReference self) -> int\n"
		"\n"
		"Get the value of the 'denominator' attribute, for the case of a\n"
		"rational-numbered stoichiometry or a model in SBML Level 1.\n"
		"\n"
		"The 'denominator' attribute is only actually written out in the case\n"
		"of an SBML Level 1 model.  In SBML Level 2, rational-number\n"
		"stoichiometries are written as MathML elements in the\n"
		"'stoichiometryMath' subelement.  However, as a convenience to users,\n"
		"libSBML allows the creation and manipulation of rational-number\n"
		"stoichiometries by supplying the numerator and denominator directly\n"
		"rather than having to manually create an ASTNode object.  LibSBML will\n"
		"write out the appropriate constructs (either a combination of\n"
		"'stoichiometry' and 'denominator' in the case of SBML Level 1, or a\n"
		"'stoichiometryMath' subelement in the case of SBML Level 2). However,\n"
		"as the 'stoichiometryMath' subelement was removed in SBML Level 3,\n"
		"automatic translation of the 'denominator' attribute is no longer\n"
		"supported for that level.\n"
		"\n"
		"Returns the value of the 'denominator' attribute of this\n"
		"SpeciesReference.\n"
		"\n"
		""},
	 { "SpeciesReference_getConstant", _wrap_SpeciesReference_getConstant, METH_O, "\n"
		"SpeciesReference_getConstant(SpeciesReference self) -> bool\n"
		"\n"
		"Get the value of the 'constant' attribute.\n"
		"\n"
		"Returns the value of the 'constant' attribute of this\n"
		"SpeciesReference.\n"
		"\n"
		""},
	 { "SpeciesReference_isSetStoichiometryMath", _wrap_SpeciesReference_isSetStoichiometryMath, METH_O, "\n"
		"SpeciesReference_isSetStoichiometryMath(SpeciesReference self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this SpeciesReference's\n"
		"'stoichiometryMath' subelement is set\n"
		"\n"
		"Returns 'True' if the 'stoichiometryMath' subelement of this\n"
		"SpeciesReference is set, 'False' otherwise.\n"
		"\n"
		""},
	 { "SpeciesReference_isSetConstant", _wrap_SpeciesReference_isSetConstant, METH_O, "\n"
		"SpeciesReference_isSetConstant(SpeciesReference self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this SpeciesReference's 'constant'\n"
		"attribute is set\n"
		"\n"
		"Returns 'True' if the 'constant' attribute of this SpeciesReference is\n"
		"set, 'False' otherwise.\n"
		"\n"
		""},
	 { "SpeciesReference_isSetStoichiometry", _wrap_SpeciesReference_isSetStoichiometry, METH_O, "\n"
		"SpeciesReference_isSetStoichiometry(SpeciesReference self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this SpeciesReference's 'stoichiometry'\n"
		"attribute is set.\n"
		"\n"
		"Returns 'True' if the 'stoichiometry' attribute of this\n"
		"SpeciesReference is set, 'False' otherwise.\n"
		"\n"
		""},
	 { "SpeciesReference_setStoichiometry", _wrap_SpeciesReference_setStoichiometry, METH_VARARGS, "\n"
		"SpeciesReference_setStoichiometry(SpeciesReference self, double value) -> int\n"
		"\n"
		"Sets the value of the 'stoichiometry' attribute of this\n"
		"SpeciesReference.\n"
		"\n"
		"In SBML Level 2, product and reactant stoichiometries can be specified\n"
		"using either 'stoichiometry' or 'stoichiometryMath' in a\n"
		"SpeciesReference object.  The former is to be used when a\n"
		"stoichiometry is simply a scalar number, while the latter is for\n"
		"occasions when it needs to be a rational number or it needs to\n"
		"reference other mathematical expressions.  The 'stoichiometry'\n"
		"attribute is of type 'float' and should contain values greater than\n"
		"zero ('0).'  The 'stoichiometryMath' element is implemented as an\n"
		"element containing a MathML expression.  These two are mutually\n"
		"exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should\n"
		"be defined in a given SpeciesReference instance.  When neither the\n"
		"attribute nor the element is present, the value of 'stoichiometry' in\n"
		"the SpeciesReference instance defaults to '1.'  For maximum\n"
		"interoperability between different software tools, the 'stoichiometry'\n"
		"attribute should be used in preference to 'stoichiometryMath' when a\n"
		"species' stoichiometry is a simple scalar number (integer or decimal).\n"
		"\n"
		"In SBML Level 3, there is no StoichiometryMath, and SpeciesReference\n"
		"objects have only the 'stoichiometry' attribute.\n"
		"\n"
		"Parameter 'value' is the new value of the 'stoichiometry' attribute.\n"
		"\n"
		"Note: In SBML Level 2, the 'stoichiometryMath' subelement of this\n"
		"SpeciesReference object will be unset because the 'stoichiometry'\n"
		"attribute and the stoichiometryMath' subelement are mutually\n"
		"exclusive.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "SpeciesReference_setStoichiometryMath", _wrap_SpeciesReference_setStoichiometryMath, METH_VARARGS, "\n"
		"SpeciesReference_setStoichiometryMath(SpeciesReference self, StoichiometryMath math) -> int\n"
		"\n"
		"Sets the 'stoichiometryMath' subelement of this SpeciesReference.\n"
		"\n"
		"The Abstract Syntax Tree in 'math' is copied.\n"
		"\n"
		"In SBML Level 2, product and reactant stoichiometries can be specified\n"
		"using either 'stoichiometry' or 'stoichiometryMath' in a\n"
		"SpeciesReference object.  The former is to be used when a\n"
		"stoichiometry is simply a scalar number, while the latter is for\n"
		"occasions when it needs to be a rational number or it needs to\n"
		"reference other mathematical expressions.  The 'stoichiometry'\n"
		"attribute is of type 'float' and should contain values greater than\n"
		"zero ('0).'  The 'stoichiometryMath' element is implemented as an\n"
		"element containing a MathML expression.  These two are mutually\n"
		"exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should\n"
		"be defined in a given SpeciesReference instance.  When neither the\n"
		"attribute nor the element is present, the value of 'stoichiometry' in\n"
		"the SpeciesReference instance defaults to '1.'  For maximum\n"
		"interoperability between different software tools, the 'stoichiometry'\n"
		"attribute should be used in preference to 'stoichiometryMath' when a\n"
		"species' stoichiometry is a simple scalar number (integer or decimal).\n"
		"\n"
		"In SBML Level 3, there is no StoichiometryMath, and SpeciesReference\n"
		"objects have only the 'stoichiometry' attribute.\n"
		"\n"
		"Parameter 'math' is the StoichiometryMath expression that is to be\n"
		"copied as the content of the 'stoichiometryMath' subelement.\n"
		"\n"
		"Note: In SBML Level 2, the 'stoichiometry' attribute of this\n"
		"SpeciesReference object will be unset (isSetStoichiometry() will\n"
		"return 'False' although getStoichiometry() will return '1.0)' if the\n"
		"given math is not null because the 'stoichiometry' attribute and the\n"
		"stoichiometryMath' subelement are mutually exclusive.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		""},
	 { "SpeciesReference_setDenominator", _wrap_SpeciesReference_setDenominator, METH_VARARGS, "\n"
		"SpeciesReference_setDenominator(SpeciesReference self, int value) -> int\n"
		"\n"
		"Set the value of the 'denominator' attribute, for the case of a\n"
		"rational-numbered stoichiometry or a model in SBML Level 1.\n"
		"\n"
		"The 'denominator' attribute is only actually written out in the case\n"
		"of an SBML Level 1 model.  In SBML Level 2, rational-number\n"
		"stoichiometries are written as MathML elements in the\n"
		"'stoichiometryMath' subelement.  However, as a convenience to users,\n"
		"libSBML allows the creation and manipulation of rational-number\n"
		"stoichiometries by supplying the numerator and denominator directly\n"
		"rather than having to manually create an ASTNode object.  LibSBML will\n"
		"write out the appropriate constructs (either a combination of\n"
		"'stoichiometry' and 'denominator' in the case of SBML Level 1, or a\n"
		"'stoichiometryMath' subelement in the case of SBML Level 2). However,\n"
		"as the 'stoichiometryMath' subelement was removed in SBML Level 3,\n"
		"automatic translation of the 'denominator'  attribute is no longer\n"
		"supported for that level.\n"
		"\n"
		"Parameter 'value' is the scalar value.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		""},
	 { "SpeciesReference_setConstant", _wrap_SpeciesReference_setConstant, METH_VARARGS, "\n"
		"SpeciesReference_setConstant(SpeciesReference self, bool flag) -> int\n"
		"\n"
		"Sets the 'constant' attribute of this SpeciesReference to the given\n"
		"boolean 'flag'.\n"
		"\n"
		"Parameter 'flag' is a boolean, the value for the 'constant' attribute\n"
		"of this SpeciesReference instance.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		""},
	 { "SpeciesReference_unsetStoichiometryMath", _wrap_SpeciesReference_unsetStoichiometryMath, METH_O, "\n"
		"SpeciesReference_unsetStoichiometryMath(SpeciesReference self) -> int\n"
		"\n"
		"Unsets the 'stoichiometryMath' subelement of this SpeciesReference.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"In SBML Level 2, product and reactant stoichiometries can be specified\n"
		"using either 'stoichiometry' or 'stoichiometryMath' in a\n"
		"SpeciesReference object.  The former is to be used when a\n"
		"stoichiometry is simply a scalar number, while the latter is for\n"
		"occasions when it needs to be a rational number or it needs to\n"
		"reference other mathematical expressions.  The 'stoichiometry'\n"
		"attribute is of type 'float' and should contain values greater than\n"
		"zero ('0).'  The 'stoichiometryMath' element is implemented as an\n"
		"element containing a MathML expression.  These two are mutually\n"
		"exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should\n"
		"be defined in a given SpeciesReference instance.  When neither the\n"
		"attribute nor the element is present, the value of 'stoichiometry' in\n"
		"the SpeciesReference instance defaults to '1.'  For maximum\n"
		"interoperability between different software tools, the 'stoichiometry'\n"
		"attribute should be used in preference to 'stoichiometryMath' when a\n"
		"species' stoichiometry is a simple scalar number (integer or decimal).\n"
		"\n"
		"In SBML Level 3, there is no StoichiometryMath, and SpeciesReference\n"
		"objects have only the 'stoichiometry' attribute.\n"
		"\n"
		"Note: In SBML Level 2, the 'stoichiometry' attribute of this\n"
		"SpeciesReference object will be reset to a default value ('1.0)' if\n"
		"the 'stoichiometry' attribute has not been set.\n"
		"\n"
		""},
	 { "SpeciesReference_unsetStoichiometry", _wrap_SpeciesReference_unsetStoichiometry, METH_O, "\n"
		"SpeciesReference_unsetStoichiometry(SpeciesReference self) -> int\n"
		"\n"
		"Unsets the 'stoichiometry' attribute of this SpeciesReference.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: In SBML Level 1, the 'stoichiometry' attribute of this\n"
		"SpeciesReference object will be just reset to a default value ('1.0)'\n"
		"and isSetStoichiometry() will still return 'True.'  In SBML Level 2,\n"
		"the 'stoichiometry' attribute of this object will be unset (which will\n"
		"result in isSetStoichiometry() returning 'False,' although\n"
		"getStoichiometry() will return '1.0)' if the 'stoichiometryMath'\n"
		"subelement is set, otherwise the attribute will be just reset to the\n"
		"default value ('1.0)' (and isSetStoichiometry() will still return\n"
		"'True).'  In SBML Level 3, the 'stoichiometry' attribute of this\n"
		"object will be set to 'NaN' and isSetStoichiometry() will return\n"
		"'False.'\n"
		"\n"
		""},
	 { "SpeciesReference_unsetConstant", _wrap_SpeciesReference_unsetConstant, METH_O, "\n"
		"SpeciesReference_unsetConstant(SpeciesReference self) -> int\n"
		"\n"
		"Unsets the 'constant' attribute of this SpeciesReference.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		""},
	 { "SpeciesReference_createStoichiometryMath", _wrap_SpeciesReference_createStoichiometryMath, METH_O, "\n"
		"SpeciesReference_createStoichiometryMath(SpeciesReference self) -> StoichiometryMath\n"
		"\n"
		"Creates a new, empty StoichiometryMath object, adds it to this\n"
		"SpeciesReference, and returns it.\n"
		"\n"
		"Returns the newly created StoichiometryMath object instance.\n"
		"\n"
		"Note: This function has no effect on SBML Level 1 or Level 3\n"
		"SpeciesReference objects, neither of which have StoichiometryMath\n"
		"children.\n"
		"\n"
		"See also Reaction.addReactant(), Reaction.addProduct().\n"
		"\n"
		""},
	 { "SpeciesReference_setAnnotation", _wrap_SpeciesReference_setAnnotation, METH_VARARGS, "\n"
		"SpeciesReference_setAnnotation(SpeciesReference self, XMLNode annotation) -> int\n"
		"SpeciesReference_setAnnotation(SpeciesReference self, string annotation) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setAnnotation(XMLNode annotation)\n"
		"\n"
		"Sets the value of the 'annotation' subelement of this SBML object to a\n"
		"copy of 'annotation'.\n"
		"\n"
		"Any existing content of the 'annotation' subelement is discarded.\n"
		"Unless you have taken steps to first copy and reconstitute any\n"
		"existing annotations into the 'annotation' that is about to be\n"
		"assigned, it is likely that performing such wholesale replacement is\n"
		"unfriendly towards other software applications whose annotations are\n"
		"discarded.  An alternative may be to use appendAnnotation().\n"
		"\n"
		"Parameter 'annotation' is an XML structure that is to be used as the\n"
		"content of the 'annotation' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also appendAnnotation(), appendAnnotation().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setAnnotation(string annotation)\n"
		"\n"
		"Sets the value of the 'annotation' subelement of this SBML object to a\n"
		"copy of 'annotation'.\n"
		"\n"
		"Any existing content of the 'annotation' subelement is discarded.\n"
		"Unless you have taken steps to first copy and reconstitute any\n"
		"existing annotations into the 'annotation' that is about to be\n"
		"assigned, it is likely that performing such wholesale replacement is\n"
		"unfriendly towards other software applications whose annotations are\n"
		"discarded.  An alternative may be to use appendAnnotation().\n"
		"\n"
		"Parameter 'annotation' is an XML string that is to be used as the\n"
		"content of the 'annotation' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also appendAnnotation(), appendAnnotation().\n"
		"\n"
		""},
	 { "SpeciesReference_appendAnnotation", _wrap_SpeciesReference_appendAnnotation, METH_VARARGS, "\n"
		"SpeciesReference_appendAnnotation(SpeciesReference self, XMLNode annotation) -> int\n"
		"SpeciesReference_appendAnnotation(SpeciesReference self, string annotation) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    appendAnnotation(XMLNode annotation)\n"
		"\n"
		"Appends annotation content to any existing content in the 'annotation'\n"
		"subelement of this object.\n"
		"\n"
		"The content in 'annotation' is copied.  Unlike\n"
		"SpeciesReference.setAnnotation(), this method allows other annotations\n"
		"to be preserved when an application adds its own data.\n"
		"\n"
		"Parameter 'annotation' is an XML structure that is to be copied and\n"
		"appended to the content of the 'annotation' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also setAnnotation(), setAnnotation().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    appendAnnotation(string annotation)\n"
		"\n"
		"Appends annotation content to any existing content in the 'annotation'\n"
		"subelement of this object.\n"
		"\n"
		"The content in 'annotation' is copied.  Unlike\n"
		"SpeciesReference.setAnnotation(), this method allows other annotations\n"
		"to be preserved when an application adds its own data.\n"
		"\n"
		"Parameter 'annotation' is an XML string that is to be copied and\n"
		"appended to the content of the 'annotation' subelement of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also setAnnotation(), setAnnotation().\n"
		"\n"
		""},
	 { "SpeciesReference_getTypeCode", _wrap_SpeciesReference_getTypeCode, METH_O, "\n"
		"SpeciesReference_getTypeCode(SpeciesReference self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_SPECIES_REFERENCE\n"
		"(default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "SpeciesReference_getElementName", _wrap_SpeciesReference_getElementName, METH_O, "\n"
		"SpeciesReference_getElementName(SpeciesReference self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for\n"
		"SpeciesReference, is always ''speciesReference'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''speciesReference'.'\n"
		"\n"
		""},
	 { "SpeciesReference_hasRequiredAttributes", _wrap_SpeciesReference_hasRequiredAttributes, METH_O, "\n"
		"SpeciesReference_hasRequiredAttributes(SpeciesReference self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"SpeciesReference object have been set.\n"
		"\n"
		"The required attributes for a SpeciesReference object are:\n"
		"\n"
		"* 'species'\n"
		"\n"
		"* 'constant' (only available SBML Level 3)\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SpeciesReference_swigregister", SpeciesReference_swigregister, METH_O, NULL},
	 { "SpeciesReference_swiginit", SpeciesReference_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfSpeciesReferences", _wrap_new_ListOfSpeciesReferences, METH_VARARGS, "\n"
		"ListOfSpeciesReferences(unsigned int level, unsigned int version)\n"
		"new_ListOfSpeciesReferences(SBMLNamespaces sbmlns) -> ListOfSpeciesReferences\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfSpeciesReferences(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfSpeciesReferences object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfSpeciesReferences object to\n"
		"be created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfSpeciesReferences(long level, long version)\n"
		"\n"
		"Creates a new, empty ListOfSpeciesReferences object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfSpeciesReferences_clone", _wrap_ListOfSpeciesReferences_clone, METH_O, "\n"
		"ListOfSpeciesReferences_clone(ListOfSpeciesReferences self) -> ListOfSpeciesReferences\n"
		"\n"
		"Creates and returns a deep copy of this ListOfSpeciesReferences\n"
		"object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfSpeciesReferences object.\n"
		"\n"
		""},
	 { "ListOfSpeciesReferences_getItemTypeCode", _wrap_ListOfSpeciesReferences_getItemTypeCode, METH_O, "\n"
		"ListOfSpeciesReferences_getItemTypeCode(ListOfSpeciesReferences self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., SpeciesReference objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for objects contained in this list:\n"
		"SBML_SPECIES_REFERENCE (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfSpeciesReferences_getElementName", _wrap_ListOfSpeciesReferences_getElementName, METH_O, "\n"
		"ListOfSpeciesReferences_getElementName(ListOfSpeciesReferences self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfSpeciesReferences, the XML element name is\n"
		"''listOfSpeciesReferences'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfSpeciesReferences'.'\n"
		"\n"
		""},
	 { "ListOfSpeciesReferences_get", _wrap_ListOfSpeciesReferences_get, METH_VARARGS, "\n"
		"ListOfSpeciesReferences_get(ListOfSpeciesReferences self, unsigned int n) -> SimpleSpeciesReference\n"
		"ListOfSpeciesReferences_get(ListOfSpeciesReferences self, unsigned int n) -> SimpleSpeciesReference\n"
		"ListOfSpeciesReferences_get(ListOfSpeciesReferences self, string sid) -> SimpleSpeciesReference\n"
		"ListOfSpeciesReferences_get(ListOfSpeciesReferences self, string sid) -> SimpleSpeciesReference\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Get a SpeciesReference from the ListOfSpeciesReferences.\n"
		"\n"
		"Parameter 'n' is the index number of the SpeciesReference to get.\n"
		"\n"
		"Returns the nth SpeciesReference in this ListOfSpeciesReferences. If\n"
		"the index 'n' is invalid, 'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Get a SpeciesReference from the ListOfSpeciesReferences based on its\n"
		"identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier  of the\n"
		"SpeciesReference to get.\n"
		"\n"
		"Returns SpeciesReference in this ListOfSpeciesReferences with the\n"
		"given 'sid' or 'None' if no such SpeciesReference exists.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfSpeciesReferences_remove", _wrap_ListOfSpeciesReferences_remove, METH_VARARGS, "\n"
		"ListOfSpeciesReferences_remove(ListOfSpeciesReferences self, unsigned int n) -> SimpleSpeciesReference\n"
		"ListOfSpeciesReferences_remove(ListOfSpeciesReferences self, string sid) -> SimpleSpeciesReference\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfSpeciesReferences items and\n"
		"returns a pointer to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes item in this ListOfSpeciesReferences items with the given\n"
		"identifier.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"If none of the items in this list have the identifier 'sid', then\n"
		"'None' is returned.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  As mentioned above, the caller owns the\n"
		"returned item.\n"
		"\n"
		""},
	 { "ListOfSpeciesReferences_getType", _wrap_ListOfSpeciesReferences_getType, METH_O, "\n"
		"ListOfSpeciesReferences_getType(ListOfSpeciesReferences self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "delete_ListOfSpeciesReferences", _wrap_delete_ListOfSpeciesReferences, METH_O, "delete_ListOfSpeciesReferences(ListOfSpeciesReferences self)"},
	 { "ListOfSpeciesReferences_swigregister", ListOfSpeciesReferences_swigregister, METH_O, NULL},
	 { "ListOfSpeciesReferences_swiginit", ListOfSpeciesReferences_swiginit, METH_VARARGS, NULL},
	 { "new_ModifierSpeciesReference", _wrap_new_ModifierSpeciesReference, METH_VARARGS, "\n"
		"ModifierSpeciesReference(unsigned int level, unsigned int version)\n"
		"new_ModifierSpeciesReference(SBMLNamespaces sbmlns) -> ModifierSpeciesReference\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ModifierSpeciesReference(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ModifierSpeciesReference using the given SBMLNamespaces\n"
		"object 'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ModifierSpeciesReference(long level, long version)\n"
		"\n"
		"Creates a new ModifierSpeciesReference using the given SBML 'level'\n"
		"and 'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"ModifierSpeciesReference.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this ModifierSpeciesReference.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "delete_ModifierSpeciesReference", _wrap_delete_ModifierSpeciesReference, METH_O, "delete_ModifierSpeciesReference(ModifierSpeciesReference self)"},
	 { "ModifierSpeciesReference_clone", _wrap_ModifierSpeciesReference_clone, METH_O, "\n"
		"ModifierSpeciesReference_clone(ModifierSpeciesReference self) -> ModifierSpeciesReference\n"
		"\n"
		"Creates and returns a deep copy of this ModifierSpeciesReference\n"
		"object.\n"
		"\n"
		"Returns the (deep) copy of this ModifierSpeciesReference object.\n"
		"\n"
		""},
	 { "ModifierSpeciesReference_getTypeCode", _wrap_ModifierSpeciesReference_getTypeCode, METH_O, "\n"
		"ModifierSpeciesReference_getTypeCode(ModifierSpeciesReference self) -> int\n"
		"\n"
		"Returns the libSBML type code for this SBML object.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object:\n"
		"SBML_MODIFIER_SPECIES_REFERENCE (default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ModifierSpeciesReference_getElementName", _wrap_ModifierSpeciesReference_getElementName, METH_O, "\n"
		"ModifierSpeciesReference_getElementName(ModifierSpeciesReference self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for Species, is\n"
		"always ''modifierSpeciesReference'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''modifierSpeciesReference'.'\n"
		"\n"
		""},
	 { "ModifierSpeciesReference_hasRequiredAttributes", _wrap_ModifierSpeciesReference_hasRequiredAttributes, METH_O, "\n"
		"ModifierSpeciesReference_hasRequiredAttributes(ModifierSpeciesReference self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"ModifierSpeciesReference object have been set.\n"
		"\n"
		"The required attributes for a ModifierSpeciesReference object are:\n"
		"species\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ModifierSpeciesReference_swigregister", ModifierSpeciesReference_swigregister, METH_O, NULL},
	 { "ModifierSpeciesReference_swiginit", ModifierSpeciesReference_swiginit, METH_VARARGS, NULL},
	 { "delete_Event", _wrap_delete_Event, METH_O, "delete_Event(Event self)"},
	 { "new_Event", _wrap_new_Event, METH_VARARGS, "\n"
		"Event(unsigned int level, unsigned int version)\n"
		"Event(SBMLNamespaces sbmlns)\n"
		"new_Event(Event orig) -> Event\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Event(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new Event using the given SBMLNamespaces object 'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Event(long level, long version)\n"
		"\n"
		"Creates a new Event using the given SBML 'level' and 'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"Event.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this Event.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Event(Event orig)\n"
		"\n"
		"Copy constructor; creates a copy of this Event.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "Event_clone", _wrap_Event_clone, METH_O, "\n"
		"Event_clone(Event self) -> Event\n"
		"\n"
		"Creates and returns a deep copy of this Event object.\n"
		"\n"
		"Returns the (deep) copy of this Event object.\n"
		"\n"
		""},
	 { "Event_initDefaults", _wrap_Event_initDefaults, METH_O, "\n"
		"Event_initDefaults(Event self)\n"
		"\n"
		"Initializes the fields of this Event object to 'typical' default\n"
		"values.\n"
		"\n"
		"The SBML Event component has slightly different aspects and default\n"
		"attribute values in different SBML Levels and Versions. This method\n"
		"sets the values to certain common defaults, based mostly on what they\n"
		"are in SBML Level 2.  Specifically:\n"
		"\n"
		"* Sets attribute 'useValuesFromTriggerTime' to 'True'\n"
		"\n"
		""},
	 { "Event_getElementBySId", _wrap_Event_getElementBySId, METH_VARARGS, "\n"
		"Event_getElementBySId(Event self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given 'id' in the\n"
		"model-wide SId namespace, or 'None' if no such object is found.\n"
		"\n"
		"Parameter 'id' is string representing the id of the object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'id'.\n"
		"\n"
		""},
	 { "Event_getElementByMetaId", _wrap_Event_getElementByMetaId, METH_VARARGS, "\n"
		"Event_getElementByMetaId(Event self, string metaid) -> SBase\n"
		"\n"
		"Returns the first child element it can find with the given 'metaid',\n"
		"or 'None' if no such object is found.\n"
		"\n"
		"Parameter 'metaid' is string representing the metaid of the object to\n"
		"find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'metaid'.\n"
		"\n"
		""},
	 { "Event_getId", _wrap_Event_getId, METH_O, "\n"
		"Event_getId(Event self) -> string\n"
		"\n"
		"Returns the value of the 'id' attribute of this Event.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() function instead.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns the id of this Event.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Event_getName", _wrap_Event_getName, METH_O, "\n"
		"Event_getName(Event self) -> string\n"
		"\n"
		"Returns the value of the 'name' attribute of this Event.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns the name of this SBML object, or the empty string if not set\n"
		"or unsettable.\n"
		"\n"
		"See also getIdAttribute(), isSetName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "Event_getTrigger", _wrap_Event_getTrigger, METH_VARARGS, "\n"
		"Event_getTrigger(Event self) -> Trigger\n"
		"Event_getTrigger(Event self) -> Trigger\n"
		"\n"
		"Get the event trigger portion of this Event.\n"
		"\n"
		"Returns the Trigger object of this Event, or 'None' if the trigger is\n"
		"not set.\n"
		"\n"
		""},
	 { "Event_getDelay", _wrap_Event_getDelay, METH_VARARGS, "\n"
		"Event_getDelay(Event self) -> Delay\n"
		"Event_getDelay(Event self) -> Delay\n"
		"\n"
		"Get the assignment delay portion of this Event, if there is one.\n"
		"\n"
		"Returns the delay of this Event if one is defined, or 'None' if none\n"
		"is defined.\n"
		"\n"
		""},
	 { "Event_getPriority", _wrap_Event_getPriority, METH_VARARGS, "\n"
		"Event_getPriority(Event self) -> Priority\n"
		"Event_getPriority(Event self) -> Priority\n"
		"\n"
		"(SBML Level 3 only) Get the event priority portion of this Event.\n"
		"\n"
		"Returns the Priority object of this Event, or 'None' if the Priority\n"
		"has not been set.\n"
		"\n"
		"Note: The element 'priority' is available in SBML Level 3, but is not\n"
		"present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Event_getTimeUnits", _wrap_Event_getTimeUnits, METH_O, "\n"
		"Event_getTimeUnits(Event self) -> string\n"
		"\n"
		"Get the value of the 'timeUnits' attribute of this Event, if it has\n"
		"one.\n"
		"\n"
		"Returns the value of the attribute 'timeUnits' as a string.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Definitions of Event in SBML Level 2 Versions 1 and 2 included the\n"
		"additional attribute called 'timeUnits', but it was removed in SBML\n"
		"Level 2 Version 3. LibSBML supports this attribute for compatibility\n"
		"with previous versions of SBML Level 2, but its use is discouraged\n"
		"since models in Level 2 Versions 3 and 4 cannot contain it.  If a\n"
		"Version 3 or 4 model sets the attribute, the consistency-checking\n"
		"method SBMLDocument.checkConsistency() will report an error.\n"
		"\n"
		""},
	 { "Event_getUseValuesFromTriggerTime", _wrap_Event_getUseValuesFromTriggerTime, METH_O, "\n"
		"Event_getUseValuesFromTriggerTime(Event self) -> bool\n"
		"\n"
		"Get the value of the 'useValuesFromTriggerTime' attribute of this\n"
		"Event.\n"
		"\n"
		"The optional Delay on Event and the fact that multiple events may be\n"
		"simultaneously executed means there are two times to consider when\n"
		"computing the results of an event: the time at which the event is\n"
		"triggered, and the time at which assignments are executed.  It is also\n"
		"possible to distinguish between the time at which the\n"
		"EventAssignment's expression is calculated, and the time at which the\n"
		"assignment is made: the expression could be evaluated at the same time\n"
		"the assignments are performed, i.e., when the event is executed, but\n"
		"it could also be defined to be evaluated at the time the event is\n"
		"triggered.\n"
		"\n"
		"In SBML Level 2 versions prior to Version 4, the semantics of Event\n"
		"time delays were defined such that the expressions in the event's\n"
		"assignments were always evaluated at the time the event was triggered.\n"
		"This definition made it difficult to define an event whose assignment\n"
		"formulas were meant to be evaluated at the time the event was executed\n"
		"(i.e., after the time period defined by the value of the Delay\n"
		"element, or after any other simultaneous event may have been executed\n"
		"and changed the model state). In SBML Level 2 Version 4, the attribute\n"
		"'useValuesFromTriggerTime' on Event allows a model to indicate the\n"
		"time at which the event's assignments are intended to be evaluated.\n"
		"In SBML Level 2, the attribute has a default value of 'True,' which\n"
		"corresponds to the interpretation of event assignments prior to\n"
		"Version 4: the values of the assignment formulas are computed at the\n"
		"moment the event is triggered, not after the delay.  If\n"
		"'useValuesFromTriggerTime'='False,' it means that the formulas in the\n"
		"event's assignments are to be computed after the delay, at the time\n"
		"the event is executed.  In SBML Level 3, the attribute is mandatory,\n"
		"not optional, and all events must specify a value for it.\n"
		"\n"
		"Returns the value of the attribute 'useValuesFromTriggerTime' as a\n"
		"boolean.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The attribute 'useValuesFromTriggerTime' was introduced in SBML Level\n"
		"2 Version 4.  It is not valid in models defined using SBML Level 2\n"
		"versions prior to Version 4. If a Level 2 Version 1-3 model sets the\n"
		"attribute, the consistency-checking method\n"
		"SBMLDocument.checkConsistency() will report an error.\n"
		"\n"
		""},
	 { "Event_isSetId", _wrap_Event_isSetId, METH_O, "\n"
		"Event_isSetId(Event self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Event's 'id' attribute is set.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns 'True' if the 'id' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is recommended that callers use\n"
		"isSetIdAttribute() instead.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),\n"
		"isSetIdAttribute().\n"
		"\n"
		""},
	 { "Event_isSetName", _wrap_Event_isSetName, METH_O, "\n"
		"Event_isSetName(Event self) -> bool\n"
		"\n"
		"Predicate returning 'True' if this Event's 'name' attribute is set.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns 'True' if the 'name' attribute of this SBML object is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also getName(), setName(), unsetName().\n"
		"\n"
		""},
	 { "Event_isSetTrigger", _wrap_Event_isSetTrigger, METH_O, "\n"
		"Event_isSetTrigger(Event self) -> bool\n"
		"\n"
		"Predicate for testing whether the trigger for this Event is set.\n"
		"\n"
		"Returns 'True' if the trigger of this Event is set, 'False' otherwise.\n"
		"\n"
		""},
	 { "Event_isSetDelay", _wrap_Event_isSetDelay, METH_O, "\n"
		"Event_isSetDelay(Event self) -> bool\n"
		"\n"
		"Predicate for testing whether the delay for this Event is set.\n"
		"\n"
		"Returns 'True' if the delay of this Event is set, 'False' otherwise.\n"
		"\n"
		""},
	 { "Event_isSetPriority", _wrap_Event_isSetPriority, METH_O, "\n"
		"Event_isSetPriority(Event self) -> bool\n"
		"\n"
		"(SBML Level 3 only) Predicate for testing whether the priority for\n"
		"this Event is set.\n"
		"\n"
		"Returns 'True' if the priority of this Event is set, 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: The element 'priority' is available in SBML Level 3, but is not\n"
		"present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Event_isSetTimeUnits", _wrap_Event_isSetTimeUnits, METH_O, "\n"
		"Event_isSetTimeUnits(Event self) -> bool\n"
		"\n"
		"Predicate for testing whether the 'timeUnits' attribute of this Event\n"
		"is set.\n"
		"\n"
		"Returns 'True' if the 'timeUnits' attribute of this Event is set,\n"
		"'False' otherwise.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Definitions of Event in SBML Level 2 Versions 1 and 2 included the\n"
		"additional attribute called 'timeUnits', but it was removed in SBML\n"
		"Level 2 Version 3. LibSBML supports this attribute for compatibility\n"
		"with previous versions of SBML Level 2, but its use is discouraged\n"
		"since models in Level 2 Versions 3 and 4 cannot contain it.  If a\n"
		"Version 3 or 4 model sets the attribute, the consistency-checking\n"
		"method SBMLDocument.checkConsistency() will report an error.\n"
		"\n"
		""},
	 { "Event_isSetUseValuesFromTriggerTime", _wrap_Event_isSetUseValuesFromTriggerTime, METH_O, "\n"
		"Event_isSetUseValuesFromTriggerTime(Event self) -> bool\n"
		"\n"
		"Predicate for testing whether the 'useValuesFromTriggerTime' attribute\n"
		"of this Event is set.\n"
		"\n"
		"Returns 'True' if the 'useValuesFromTriggerTime' attribute of this\n"
		"Event is set, 'False' otherwise.\n"
		"\n"
		"Note: In SBML Level 2, this attribute is optional and has a default\n"
		"value of 'True,' whereas in Level 3, this optional is mandatory and\n"
		"has no default value.\n"
		"\n"
		""},
	 { "Event_setId", _wrap_Event_setId, METH_VARARGS, "\n"
		"Event_setId(Event self, string sid) -> int\n"
		"\n"
		"Sets the value of the 'id' attribute of this Event.\n"
		"\n"
		"The string 'sid' is copied.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Parameter 'sid' is the string to use as the identifier of this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Event_setName", _wrap_Event_setName, METH_VARARGS, "\n"
		"Event_setName(Event self, string name) -> int\n"
		"\n"
		"Sets the value of the 'name' attribute of this Event.\n"
		"\n"
		"The string in 'name' is copied.\n"
		"\n"
		"Parameter 'name' is the new name for the SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Event_setTrigger", _wrap_Event_setTrigger, METH_VARARGS, "\n"
		"Event_setTrigger(Event self, Trigger trigger) -> int\n"
		"\n"
		"Sets the trigger definition of this Event to a copy of the given\n"
		"Trigger object instance.\n"
		"\n"
		"Parameter 'trigger' is the Trigger object instance to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		""},
	 { "Event_setDelay", _wrap_Event_setDelay, METH_VARARGS, "\n"
		"Event_setDelay(Event self, Delay delay) -> int\n"
		"\n"
		"Sets the delay definition of this Event to a copy of the given Delay\n"
		"object instance.\n"
		"\n"
		"Parameter 'delay' is the Delay object instance to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		""},
	 { "Event_setPriority", _wrap_Event_setPriority, METH_VARARGS, "\n"
		"Event_setPriority(Event self, Priority priority) -> int\n"
		"\n"
		"(SBML Level 3 only) Sets the priority definition of this Event to a\n"
		"copy of the given Priority object instance.\n"
		"\n"
		"Parameter 'priority' is the Priority object instance to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The element 'priority' is available in SBML Level 3, but is not\n"
		"present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Event_setTimeUnits", _wrap_Event_setTimeUnits, METH_VARARGS, "\n"
		"Event_setTimeUnits(Event self, string sid) -> int\n"
		"\n"
		"Sets the 'timeUnits' attribute of this Event to a copy of 'sid'.\n"
		"\n"
		"Parameter 'sid' is the identifier of the time units to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Definitions of Event in SBML Level 2 Versions 1 and 2 included the\n"
		"additional attribute called 'timeUnits', but it was removed in SBML\n"
		"Level 2 Version 3. LibSBML supports this attribute for compatibility\n"
		"with previous versions of SBML Level 2, but its use is discouraged\n"
		"since models in Level 2 Versions 3 and 4 cannot contain it.  If a\n"
		"Version 3 or 4 model sets the attribute, the consistency-checking\n"
		"method SBMLDocument.checkConsistency() will report an error.\n"
		"\n"
		""},
	 { "Event_setUseValuesFromTriggerTime", _wrap_Event_setUseValuesFromTriggerTime, METH_VARARGS, "\n"
		"Event_setUseValuesFromTriggerTime(Event self, bool value) -> int\n"
		"\n"
		"Sets the 'useValuesFromTriggerTime' attribute of this Event to a\n"
		"'value'.\n"
		"\n"
		"The optional Delay on Event and the fact that multiple events may be\n"
		"simultaneously executed means there are two times to consider when\n"
		"computing the results of an event: the time at which the event is\n"
		"triggered, and the time at which assignments are executed.  It is also\n"
		"possible to distinguish between the time at which the\n"
		"EventAssignment's expression is calculated, and the time at which the\n"
		"assignment is made: the expression could be evaluated at the same time\n"
		"the assignments are performed, i.e., when the event is executed, but\n"
		"it could also be defined to be evaluated at the time the event is\n"
		"triggered.\n"
		"\n"
		"In SBML Level 2 versions prior to Version 4, the semantics of Event\n"
		"time delays were defined such that the expressions in the event's\n"
		"assignments were always evaluated at the time the event was triggered.\n"
		"This definition made it difficult to define an event whose assignment\n"
		"formulas were meant to be evaluated at the time the event was executed\n"
		"(i.e., after the time period defined by the value of the Delay\n"
		"element, or after any other simultaneous event may have been executed\n"
		"and changed the model state). In SBML Level 2 Version 4, the attribute\n"
		"'useValuesFromTriggerTime' on Event allows a model to indicate the\n"
		"time at which the event's assignments are intended to be evaluated.\n"
		"In SBML Level 2, the attribute has a default value of 'True,' which\n"
		"corresponds to the interpretation of event assignments prior to\n"
		"Version 4: the values of the assignment formulas are computed at the\n"
		"moment the event is triggered, not after the delay.  If\n"
		"'useValuesFromTriggerTime'='False,' it means that the formulas in the\n"
		"event's assignments are to be computed after the delay, at the time\n"
		"the event is executed.  In SBML Level 3, the attribute is mandatory,\n"
		"not optional, and all events must specify a value for it.\n"
		"\n"
		"Parameter 'value' is the value of useValuesFromTriggerTime to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The attribute 'useValuesFromTriggerTime' was introduced in SBML Level\n"
		"2 Version 4.  It is not valid in models defined using SBML Level 2\n"
		"versions prior to Version 4. If a Level 2 Version 1-3 model sets the\n"
		"attribute, the consistency-checking method\n"
		"SBMLDocument.checkConsistency() will report an error.\n"
		"\n"
		""},
	 { "Event_unsetId", _wrap_Event_unsetId, METH_O, "\n"
		"Event_unsetId(Event self) -> int\n"
		"\n"
		"Unsets the value of the 'id' attribute of this Event.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The characters ( and ) are used for grouping, the character * 'zero or\n"
		"more times', and the character | indicates logical 'or'.  The equality\n"
		"of SBML identifiers is determined by an exact character sequence\n"
		"match; i.e., comparisons must be performed in a case-sensitive manner.\n"
		"This applies to all uses of SId, SIdRef, and derived types.\n"
		"\n"
		"Users need to be aware of some important API issues that are the\n"
		"result of the history of SBML and libSBML.  Prior to SBML Level 3\n"
		"Version 2, SBML defined 'id' and 'name' attributes on only a subset of\n"
		"SBML objects.  To simplify the work of programmers, libSBML's API\n"
		"provided get, set, check, and unset on the SBase object class itself\n"
		"instead of on individual subobject classes. This made the get/set/etc.\n"
		"methods uniformly available on all objects in the libSBML API.\n"
		"LibSBML simply returned empty strings or otherwise did not act when\n"
		"the methods were applied to SBML objects that were not defined by the\n"
		"SBML specification to have 'id' or 'name' attributes.  Additional\n"
		"complications arose with the rule and assignment objects:\n"
		"InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In\n"
		"early versions of SBML, the rule object hierarchy was different, and\n"
		"in addition, then as now, they possess different attributes:\n"
		"'variable' (for the rules and event assignments), 'symbol' (for\n"
		"initial assignments), or neither (for algebraic rules).  Prior to SBML\n"
		"Level 3 Version 2, getId() would always return an empty string, and\n"
		"isSetId() would always return 'False' for objects of these classes.\n"
		"\n"
		"With the addition of 'id' and 'name' attributes on SBase in Level 3\n"
		"Version 2, it became necessary to introduce a new way to interact with\n"
		"the attributes more consistently in libSBML to avoid breaking backward\n"
		"compatibility in the behavior of the original 'id' methods.  For this\n"
		"reason, libSBML provides four functions (getIdAttribute(),\n"
		"setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that\n"
		"always act on the actual 'id' attribute inherited from SBase,\n"
		"regardless of the object's type.  These new methods should be used\n"
		"instead of the older getId()/setId()/etc. methods unless the old\n"
		"behavior is somehow necessary.  Regardless of the Level and Version of\n"
		"the SBML, these functions allow client applications to use more\n"
		"generalized code in some situations (for instance, when manipulating\n"
		"objects that are all known to have identifiers).  If the object in\n"
		"question does not posess an 'id' attribute according to the SBML\n"
		"specification for the Level and Version in use, libSBML will not allow\n"
		"the identifier to be set, nor will it read or write 'id' attributes\n"
		"for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute().\n"
		"\n"
		""},
	 { "Event_unsetName", _wrap_Event_unsetName, METH_O, "\n"
		"Event_unsetName(Event self) -> int\n"
		"\n"
		"Unsets the value of the 'name' attribute of this Event.\n"
		"\n"
		"In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved\n"
		"to SBase directly, instead of being defined individually for many (but\n"
		"not all) objects.  LibSBML has for a long time provided functions\n"
		"defined on SBase itself to get, set, and unset those attributes, which\n"
		"would fail or otherwise return empty strings if executed on any object\n"
		"for which those attributes were not defined.  Now that all SBase\n"
		"objects  define those attributes, those functions now succeed for any\n"
		"object with  the appropriate level and version.\n"
		"\n"
		"The 'name' attribute is optional and is not intended to be used for\n"
		"cross-referencing purposes within a model.  Its purpose instead is to\n"
		"provide a human-readable label for the component.  The data type of\n"
		"'name' is the type string defined in XML Schema.  SBML imposes no\n"
		"restrictions as to the content of 'name' attributes beyond those\n"
		"restrictions defined by the string type in XML Schema.\n"
		"\n"
		"The recommended practice for handling 'name' is as follows.  If a\n"
		"software tool has the capability for displaying the content of 'name'\n"
		"attributes, it should display this content to the user as a\n"
		"component's label instead of the component's 'id'.  If the user\n"
		"interface does not have this capability (e.g., because it cannot\n"
		"display or use special characters in symbol names), or if the 'name'\n"
		"attribute is missing on a given component, then the user interface\n"
		"should display the value of the 'id' attribute instead.  (Script\n"
		"language interpreters are especially likely to display 'id' instead of\n"
		"'name'.)\n"
		"\n"
		"As a consequence of the above, authors of systems that automatically\n"
		"generate the values of 'id' attributes should be aware some systems\n"
		"may display the 'id''s to the user.  Authors therefore may wish to\n"
		"take some care to have their software create 'id' values that are: (a)\n"
		"reasonably easy for humans to type and read; and (b) likely to be\n"
		"meaningful, for example by making the 'id' attribute be an abbreviated\n"
		"form of the name attribute value.\n"
		"\n"
		"An additional point worth mentioning is although there are\n"
		"restrictions on the uniqueness of 'id' values, there are no\n"
		"restrictions on the uniqueness of 'name' values in a model.  This\n"
		"allows software applications leeway in assigning component\n"
		"identifiers.\n"
		"\n"
		"Regardless of the level and version of the SBML, these functions allow\n"
		"client applications to use more generalized code in some situations\n"
		"(for instance, when manipulating objects that are all known to have\n"
		"names).  If the object in question does not posess a 'name' attribute\n"
		"according to the SBML specification for the Level and Version in use,\n"
		"libSBML will not allow the name to be set, nor will it read or  write\n"
		"'name' attributes for those objects.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getName(), setName(), isSetName().\n"
		"\n"
		""},
	 { "Event_unsetUseValuesFromTriggerTime", _wrap_Event_unsetUseValuesFromTriggerTime, METH_O, "\n"
		"Event_unsetUseValuesFromTriggerTime(Event self) -> int\n"
		"\n"
		"Unsets the value of the 'useValuesFromTriggerTime' attribute of this\n"
		"Event.\n"
		"\n"
		"The optional Delay on Event and the fact that multiple events may be\n"
		"simultaneously executed means there are two times to consider when\n"
		"computing the results of an event: the time at which the event is\n"
		"triggered, and the time at which assignments are executed.  It is also\n"
		"possible to distinguish between the time at which the\n"
		"EventAssignment's expression is calculated, and the time at which the\n"
		"assignment is made: the expression could be evaluated at the same time\n"
		"the assignments are performed, i.e., when the event is executed, but\n"
		"it could also be defined to be evaluated at the time the event is\n"
		"triggered.\n"
		"\n"
		"In SBML Level 2 versions prior to Version 4, the semantics of Event\n"
		"time delays were defined such that the expressions in the event's\n"
		"assignments were always evaluated at the time the event was triggered.\n"
		"This definition made it difficult to define an event whose assignment\n"
		"formulas were meant to be evaluated at the time the event was executed\n"
		"(i.e., after the time period defined by the value of the Delay\n"
		"element, or after any other simultaneous event may have been executed\n"
		"and changed the model state). In SBML Level 2 Version 4, the attribute\n"
		"'useValuesFromTriggerTime' on Event allows a model to indicate the\n"
		"time at which the event's assignments are intended to be evaluated.\n"
		"In SBML Level 2, the attribute has a default value of 'True,' which\n"
		"corresponds to the interpretation of event assignments prior to\n"
		"Version 4: the values of the assignment formulas are computed at the\n"
		"moment the event is triggered, not after the delay.  If\n"
		"'useValuesFromTriggerTime'='False,' it means that the formulas in the\n"
		"event's assignments are to be computed after the delay, at the time\n"
		"the event is executed.  In SBML Level 3, the attribute is mandatory,\n"
		"not optional, and all events must specify a value for it.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The attribute 'useValuesFromTriggerTime' was introduced in SBML Level\n"
		"2 Version 4.  It is not valid in models defined using SBML Level 2\n"
		"versions prior to Version 4. If a Level 2 Version 1-3 model sets the\n"
		"attribute, the consistency-checking method\n"
		"SBMLDocument.checkConsistency() will report an error.\n"
		"\n"
		""},
	 { "Event_unsetDelay", _wrap_Event_unsetDelay, METH_O, "\n"
		"Event_unsetDelay(Event self) -> int\n"
		"\n"
		"Unsets the Delay of this Event.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Event_unsetPriority", _wrap_Event_unsetPriority, METH_O, "\n"
		"Event_unsetPriority(Event self) -> int\n"
		"\n"
		"(SBML Level 3 only) Unsets the Priority of this Event.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The element 'priority' is available in SBML Level 3, but is not\n"
		"present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Event_unsetTrigger", _wrap_Event_unsetTrigger, METH_O, "\n"
		"Event_unsetTrigger(Event self) -> int\n"
		"\n"
		"Unsets the Trigger of this Event.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: The element 'priority' is available in SBML Level 3, but is not\n"
		"present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Event_unsetTimeUnits", _wrap_Event_unsetTimeUnits, METH_O, "\n"
		"Event_unsetTimeUnits(Event self) -> int\n"
		"\n"
		"Unsets the 'timeUnits' attribute of this Event.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Definitions of Event in SBML Level 2 Versions 1 and 2 included the\n"
		"additional attribute called 'timeUnits', but it was removed in SBML\n"
		"Level 2 Version 3. LibSBML supports this attribute for compatibility\n"
		"with previous versions of SBML Level 2, but its use is discouraged\n"
		"since models in Level 2 Versions 3 and 4 cannot contain it.  If a\n"
		"Version 3 or 4 model sets the attribute, the consistency-checking\n"
		"method SBMLDocument.checkConsistency() will report an error.\n"
		"\n"
		""},
	 { "Event_addEventAssignment", _wrap_Event_addEventAssignment, METH_VARARGS, "\n"
		"Event_addEventAssignment(Event self, EventAssignment ea) -> int\n"
		"\n"
		"Appends a copy of the given EventAssignment to this Event.\n"
		"\n"
		"Parameter 'ea' is the EventAssignment object to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_LEVEL_MISMATCH\n"
		"\n"
		"* LIBSBML_VERSION_MISMATCH\n"
		"\n"
		"* LIBSBML_DUPLICATE_OBJECT_ID\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: This method should be used with some caution.  The fact that\n"
		"this method copies the object passed to it means that the caller will\n"
		"be left holding a physically different object instance than the one\n"
		"contained inside this object.  Changes made to the original object\n"
		"instance (such as resetting attribute values) will not affect the\n"
		"instance in this object.  In addition, the caller should make sure to\n"
		"free the original object if it is no longer being used, or else a\n"
		"memory leak will result.  Please see other methods on this class\n"
		"(particularly a corresponding method whose name begins with the word\n"
		"create) for alternatives that do not lead to these issues.\n"
		"\n"
		"See also createEventAssignment().\n"
		"\n"
		""},
	 { "Event_createEventAssignment", _wrap_Event_createEventAssignment, METH_O, "\n"
		"Event_createEventAssignment(Event self) -> EventAssignment\n"
		"\n"
		"Creates a new, empty EventAssignment, adds it to this Event's list of\n"
		"event assignments and returns the EventAssignment.\n"
		"\n"
		"Returns the newly created EventAssignment object instance.\n"
		"\n"
		"See also addEventAssignment().\n"
		"\n"
		""},
	 { "Event_createTrigger", _wrap_Event_createTrigger, METH_O, "\n"
		"Event_createTrigger(Event self) -> Trigger\n"
		"\n"
		"Creates a new, empty Trigger, adds it to this Event and  returns the\n"
		"Trigger.\n"
		"\n"
		"Returns the newly created Trigger object instance.\n"
		"\n"
		""},
	 { "Event_createDelay", _wrap_Event_createDelay, METH_O, "\n"
		"Event_createDelay(Event self) -> Delay\n"
		"\n"
		"Creates a new, empty Delay, adds it to this Event and  returns the\n"
		"Delay.\n"
		"\n"
		"Returns the newly created Delay object instance.\n"
		"\n"
		""},
	 { "Event_createPriority", _wrap_Event_createPriority, METH_O, "\n"
		"Event_createPriority(Event self) -> Priority\n"
		"\n"
		"(SBML Level 3 only) Creates a new, empty Priority, adds it to this\n"
		"Event and returns the Priority.\n"
		"\n"
		"Returns the newly created Priority object instance, or 'None' if the\n"
		"SBML level and version used for this Event does not define Priority\n"
		"children.\n"
		"\n"
		"Note: The element 'priority' is available in SBML Level 3, but is not\n"
		"present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Event_getListOfEventAssignments", _wrap_Event_getListOfEventAssignments, METH_VARARGS, "\n"
		"Event_getListOfEventAssignments(Event self) -> ListOfEventAssignments\n"
		"Event_getListOfEventAssignments(Event self) -> ListOfEventAssignments\n"
		"\n"
		"Returns the list of event assignments for this Event.\n"
		"\n"
		"Returns the list of EventAssignments for this Event.\n"
		"\n"
		""},
	 { "Event_getEventAssignment", _wrap_Event_getEventAssignment, METH_VARARGS, "\n"
		"Event_getEventAssignment(Event self, unsigned int n) -> EventAssignment\n"
		"Event_getEventAssignment(Event self, unsigned int n) -> EventAssignment\n"
		"Event_getEventAssignment(Event self, string variable) -> EventAssignment\n"
		"Event_getEventAssignment(Event self, string variable) -> EventAssignment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getEventAssignment(string variable)\n"
		"\n"
		"Return the event assignment indicated by the given 'variable'.\n"
		"\n"
		"Parameter 'variable' is a string, the identifier of the variable whose\n"
		"EventAssignment is being sought.\n"
		"\n"
		"Returns the EventAssignment for the given 'variable', or 'None' if no\n"
		"such EventAssignment exists.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getEventAssignment(long n)\n"
		"\n"
		"Return a specific EventAssignment object of this Event.\n"
		"\n"
		"Parameter 'n' is an integer, the index of the EventAssignment object\n"
		"to return.\n"
		"\n"
		"Returns the nth EventAssignment of this Event.\n"
		"\n"
		""},
	 { "Event_getNumEventAssignments", _wrap_Event_getNumEventAssignments, METH_O, "\n"
		"Event_getNumEventAssignments(Event self) -> unsigned int\n"
		"\n"
		"Returns the number of EventAssignment objects attached to this Event.\n"
		"\n"
		"Returns the number of EventAssignments in this Event.\n"
		"\n"
		""},
	 { "Event_removeEventAssignment", _wrap_Event_removeEventAssignment, METH_VARARGS, "\n"
		"Event_removeEventAssignment(Event self, unsigned int n) -> EventAssignment\n"
		"Event_removeEventAssignment(Event self, string variable) -> EventAssignment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeEventAssignment(string variable)\n"
		"\n"
		"Removes the EventAssignment object with the given 'variable' attribute\n"
		"from this Event object and returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it. If none of the EventAssignment objects in this Event object have\n"
		"the  'variable' attribute 'variable', then 'None' is returned.\n"
		"\n"
		"Parameter 'variable' is the 'variable' attribute of the\n"
		"EventAssignment object  to remove.\n"
		"\n"
		"Returns the EventAssignment object removed.  As mentioned above, the\n"
		"caller owns the returned object. 'None' is returned if no\n"
		"EventAssignment object with the 'variable' attribute exists in this\n"
		"Event object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeEventAssignment(long n)\n"
		"\n"
		"Removes the nth EventAssignment object from this Event object and\n"
		"returns a pointer to it.\n"
		"\n"
		"The caller owns the returned object and is responsible for deleting\n"
		"it.\n"
		"\n"
		"Parameter 'n' is the index of the EventAssignment object to remove.\n"
		"\n"
		"Returns the EventAssignment object removed.  As mentioned above,  the\n"
		"caller owns the returned item. 'None' is returned if the given index\n"
		"is out of range.\n"
		"\n"
		""},
	 { "Event_connectToChild", _wrap_Event_connectToChild, METH_O, "Event_connectToChild(Event self)"},
	 { "Event_enablePackageInternal", _wrap_Event_enablePackageInternal, METH_VARARGS, "\n"
		"Event_enablePackageInternal(Event self, string pkgURI, string pkgPrefix, bool flag)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Event_updateSBMLNamespace", _wrap_Event_updateSBMLNamespace, METH_VARARGS, "\n"
		"Event_updateSBMLNamespace(Event self, string package, unsigned int level, unsigned int version)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Event_getTypeCode", _wrap_Event_getTypeCode, METH_O, "\n"
		"Event_getTypeCode(Event self) -> int\n"
		"\n"
		"Returns the libSBML type code of this object instance.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_EVENT (default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "Event_getElementName", _wrap_Event_getElementName, METH_O, "\n"
		"Event_getElementName(Event self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for Event, is\n"
		"always ''event'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''event'.'\n"
		"\n"
		""},
	 { "Event_hasRequiredAttributes", _wrap_Event_hasRequiredAttributes, METH_O, "\n"
		"Event_hasRequiredAttributes(Event self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"Event object have been set.\n"
		"\n"
		"The required attributes for an Event object are:\n"
		"\n"
		"* 'useValuesfromTriggerTime' (required in SBML Level 3)\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "Event_hasRequiredElements", _wrap_Event_hasRequiredElements, METH_O, "\n"
		"Event_hasRequiredElements(Event self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this Event\n"
		"object have been set.\n"
		"\n"
		"Note: The required elements for an Event object are:\n"
		"\n"
		"* 'trigger' (required in SBML Level 2 and Level 3 Version 1;\n"
		"optional in SBML Level 3 Version 2+\n"
		"\n"
		"* 'listOfEventAssignments' (required in SBML Level 2; optional in\n"
		"Level 3)\n"
		"\n"
		""},
	 { "Event_swigregister", Event_swigregister, METH_O, NULL},
	 { "Event_swiginit", Event_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfEvents", _wrap_new_ListOfEvents, METH_VARARGS, "\n"
		"ListOfEvents(unsigned int level, unsigned int version)\n"
		"new_ListOfEvents(SBMLNamespaces sbmlns) -> ListOfEvents\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfEvents(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfEvents object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfEvents object to be\n"
		"created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfEvents(long level, long version)\n"
		"\n"
		"Creates a new ListOfEvents object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfEvents_clone", _wrap_ListOfEvents_clone, METH_O, "\n"
		"ListOfEvents_clone(ListOfEvents self) -> ListOfEvents\n"
		"\n"
		"Creates and returns a deep copy of this ListOfEvents object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfEvents object.\n"
		"\n"
		""},
	 { "ListOfEvents_getItemTypeCode", _wrap_ListOfEvents_getItemTypeCode, METH_O, "\n"
		"ListOfEvents_getItemTypeCode(ListOfEvents self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., Event objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for the objects contained in this ListOf:\n"
		"SBML_EVENT (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfEvents_getElementName", _wrap_ListOfEvents_getElementName, METH_O, "\n"
		"ListOfEvents_getElementName(ListOfEvents self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfEvents, the XML element name is ''listOfEvents'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfEvents'.'\n"
		"\n"
		""},
	 { "ListOfEvents_get", _wrap_ListOfEvents_get, METH_VARARGS, "\n"
		"ListOfEvents_get(ListOfEvents self, unsigned int n) -> Event\n"
		"ListOfEvents_get(ListOfEvents self, unsigned int n) -> Event\n"
		"ListOfEvents_get(ListOfEvents self, string sid) -> Event\n"
		"ListOfEvents_get(ListOfEvents self, string sid) -> Event\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Get an Event from the ListOfEvents.\n"
		"\n"
		"Parameter 'n' is the index number of the Event to get.\n"
		"\n"
		"Returns the nth Event in this ListOfEvents.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Get an Event from the ListOfEvents based on its identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier  of the Event\n"
		"to get.\n"
		"\n"
		"Returns Event in this ListOfEvents with the given 'sid' or 'None' if\n"
		"no such Event exists.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfEvents_remove", _wrap_ListOfEvents_remove, METH_VARARGS, "\n"
		"ListOfEvents_remove(ListOfEvents self, unsigned int n) -> Event\n"
		"ListOfEvents_remove(ListOfEvents self, string sid) -> Event\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfEvents items and returns a\n"
		"pointer to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes item in this ListOfEvents items with the given identifier.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"If none of the items in this list have the identifier 'sid', then\n"
		"'None' is returned.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  As mentioned above, the caller owns the\n"
		"returned item.\n"
		"\n"
		""},
	 { "delete_ListOfEvents", _wrap_delete_ListOfEvents, METH_O, "delete_ListOfEvents(ListOfEvents self)"},
	 { "ListOfEvents_swigregister", ListOfEvents_swigregister, METH_O, NULL},
	 { "ListOfEvents_swiginit", ListOfEvents_swiginit, METH_VARARGS, NULL},
	 { "delete_EventAssignment", _wrap_delete_EventAssignment, METH_O, "delete_EventAssignment(EventAssignment self)"},
	 { "new_EventAssignment", _wrap_new_EventAssignment, METH_VARARGS, "\n"
		"EventAssignment(unsigned int level, unsigned int version)\n"
		"EventAssignment(SBMLNamespaces sbmlns)\n"
		"new_EventAssignment(EventAssignment orig) -> EventAssignment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    EventAssignment(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new EventAssignment using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    EventAssignment(long level, long version)\n"
		"\n"
		"Creates a new EventAssignment using the given SBML 'level' and\n"
		"'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"EventAssignment.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this EventAssignment.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    EventAssignment(EventAssignment orig)\n"
		"\n"
		"Copy constructor; creates a copy of this EventAssignment.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "EventAssignment_clone", _wrap_EventAssignment_clone, METH_O, "\n"
		"EventAssignment_clone(EventAssignment self) -> EventAssignment\n"
		"\n"
		"Creates and returns a deep copy of this EventAssignment object.\n"
		"\n"
		"Returns the (deep) copy of this EventAssignment object.\n"
		"\n"
		""},
	 { "EventAssignment_getVariable", _wrap_EventAssignment_getVariable, METH_O, "\n"
		"EventAssignment_getVariable(EventAssignment self) -> string\n"
		"\n"
		"Get the value of this EventAssignment's 'variable' attribute.\n"
		"\n"
		"Returns the identifier stored in the 'variable' attribute of this\n"
		"EventAssignment.\n"
		"\n"
		""},
	 { "EventAssignment_getMath", _wrap_EventAssignment_getMath, METH_O, "\n"
		"EventAssignment_getMath(EventAssignment self) -> ASTNode\n"
		"\n"
		"Get the mathematical expression in this EventAssignment's 'math'\n"
		"subelement.\n"
		"\n"
		"Returns the top ASTNode of an abstract syntax tree representing the\n"
		"mathematical formula in this EventAssignment, or 'None' if the math is\n"
		"not set.\n"
		"\n"
		""},
	 { "EventAssignment_isSetVariable", _wrap_EventAssignment_isSetVariable, METH_O, "\n"
		"EventAssignment_isSetVariable(EventAssignment self) -> bool\n"
		"\n"
		"Predicate for testing whether the attribute 'variable' of this\n"
		"EventAssignment is set.\n"
		"\n"
		"Returns 'True' if the 'variable' attribute of this EventAssignment is\n"
		"set, 'False' otherwise.\n"
		"\n"
		""},
	 { "EventAssignment_isSetMath", _wrap_EventAssignment_isSetMath, METH_O, "\n"
		"EventAssignment_isSetMath(EventAssignment self) -> bool\n"
		"\n"
		"Predicate for testing whether the 'math' subelement of this\n"
		"EventAssignment is set.\n"
		"\n"
		"Returns 'True' if this EventAssignment has a 'math' subelement,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "EventAssignment_setVariable", _wrap_EventAssignment_setVariable, METH_VARARGS, "\n"
		"EventAssignment_setVariable(EventAssignment self, string sid) -> int\n"
		"\n"
		"Sets the attribute 'variable' of this EventAssignment to a copy of the\n"
		"given identifier string.\n"
		"\n"
		"Parameter 'sid' is the identifier of an element defined in this model\n"
		"that can vary over time.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "EventAssignment_unsetVariable", _wrap_EventAssignment_unsetVariable, METH_O, "\n"
		"EventAssignment_unsetVariable(EventAssignment self) -> int\n"
		"\n"
		"Unsets the attribute 'variable' of this EventAssignment.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "EventAssignment_setMath", _wrap_EventAssignment_setMath, METH_VARARGS, "\n"
		"EventAssignment_setMath(EventAssignment self, ASTNode math) -> int\n"
		"\n"
		"Sets the 'math' subelement of this EventAssignment to a copy of the\n"
		"given ASTNode.\n"
		"\n"
		"Parameter 'math' is an ASTNode that will be copied and stored as the\n"
		"mathematical formula for this EventAssignment.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "EventAssignment_getDerivedUnitDefinition", _wrap_EventAssignment_getDerivedUnitDefinition, METH_VARARGS, "\n"
		"EventAssignment_getDerivedUnitDefinition(EventAssignment self) -> UnitDefinition\n"
		"EventAssignment_getDerivedUnitDefinition(EventAssignment self) -> UnitDefinition\n"
		"\n"
		"Calculates and returns a UnitDefinition that expresses the units of\n"
		"measurement assumed for the 'math' expression of this EventAssignment.\n"
		"\n"
		"The units are calculated based on the mathematical expression in the\n"
		"EventAssignment and the model quantities referenced by <ci> elements\n"
		"used within that expression.  The method getDerivedUnitDefinition()\n"
		"returns the calculated units, to the extent that libSBML can compute\n"
		"them.\n"
		"\n"
		"Note: The functionality that facilitates unit analysis depends on the\n"
		"model as a whole.  Thus, in cases where the object has not been added\n"
		"to a model or the model itself is incomplete, unit analysis is not\n"
		"possible and this method will return 'None.'\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Note that it is possible the 'math' expression in the EventAssignment\n"
		"contains literal numbers or parameters with undeclared units.  In\n"
		"those cases, it is not possible to calculate the units of the overall\n"
		"expression without making assumptions.  LibSBML does not make\n"
		"assumptions about the units, and getDerivedUnitDefinition() only\n"
		"returns the units as far as it is able to determine them.  For\n"
		"example, in an expression X + Y, if X has unambiguously-defined units\n"
		"and Y does not, it will return the units of X.  When using this\n"
		"method, it is critical that callers also invoke the method\n"
		"containsUndeclaredUnits() to determine whether this situation holds.\n"
		"Callers should take suitable action in those situations.\n"
		"\n"
		"Returns a UnitDefinition that expresses the units of the math\n"
		"expression of this EventAssignment, or 'None' if one cannot be\n"
		"constructed.\n"
		"\n"
		"See also containsUndeclaredUnits().\n"
		"\n"
		""},
	 { "EventAssignment_containsUndeclaredUnits", _wrap_EventAssignment_containsUndeclaredUnits, METH_VARARGS, "\n"
		"EventAssignment_containsUndeclaredUnits(EventAssignment self) -> bool\n"
		"EventAssignment_containsUndeclaredUnits(EventAssignment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if the math expression of this\n"
		"EventAssignment contains literal numbers or parameters with undeclared\n"
		"units.\n"
		"\n"
		"The units are calculated based on the mathematical expression in the\n"
		"EventAssignment and the model quantities referenced by <ci> elements\n"
		"used within that expression.  The method getDerivedUnitDefinition()\n"
		"returns the calculated units, to the extent that libSBML can compute\n"
		"them.\n"
		"\n"
		"If the expression contains literal numbers or parameters with\n"
		"undeclared units, libSBML may not be able to compute the full units of\n"
		"the expression and will only return what it can compute.  Callers\n"
		"should always use containsUndeclaredUnits() when using\n"
		"getDerivedUnitDefinition() to decide whether the returned units may be\n"
		"incomplete.\n"
		"\n"
		"Returns 'True' if the math expression of this EventAssignment includes\n"
		"parameters/numbers  with undeclared units, 'False' otherwise.\n"
		"\n"
		"Note: A return value of 'True' indicates that the UnitDefinition\n"
		"returned by getDerivedUnitDefinition() may not accurately represent\n"
		"the units of the expression.\n"
		"\n"
		"See also getDerivedUnitDefinition().\n"
		"\n"
		""},
	 { "EventAssignment_getTypeCode", _wrap_EventAssignment_getTypeCode, METH_O, "\n"
		"EventAssignment_getTypeCode(EventAssignment self) -> int\n"
		"\n"
		"Returns the libSBML type code of this object instance.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_EVENT_ASSIGNMENT\n"
		"(default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "EventAssignment_getElementName", _wrap_EventAssignment_getElementName, METH_O, "\n"
		"EventAssignment_getElementName(EventAssignment self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for\n"
		"EventAssignment, is always ''eventAssignment'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''eventAssignment'.'\n"
		"\n"
		""},
	 { "EventAssignment_hasRequiredAttributes", _wrap_EventAssignment_hasRequiredAttributes, METH_O, "\n"
		"EventAssignment_hasRequiredAttributes(EventAssignment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"EventAssignment object have been set.\n"
		"\n"
		"The required attributes for a EventAssignment object are:\n"
		"\n"
		"* 'variable'\n"
		"\n"
		"Returns 'True' if the required attributes have been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "EventAssignment_hasRequiredElements", _wrap_EventAssignment_hasRequiredElements, METH_O, "\n"
		"EventAssignment_hasRequiredElements(EventAssignment self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this\n"
		"EventAssignment object have been set.\n"
		"\n"
		"Note: The required elements for an EventAssignment object are:\n"
		"\n"
		"* 'math' in SBML Level 2 and Level 3 Version 1.   (In SBML Level 3\n"
		"Version 2+, it is no longer required.)\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "EventAssignment_getId", _wrap_EventAssignment_getId, METH_O, "\n"
		"EventAssignment_getId(EventAssignment self) -> string\n"
		"\n"
		"Returns the value of the 'variable' attribute of this EventAssignment\n"
		"(NOT the 'id').\n"
		"\n"
		"Note: Because of the inconsistent behavior of this function with\n"
		"respect to assignments and rules, it is now recommended to use the\n"
		"getIdAttribute() or getVariable() instead.\n"
		"\n"
		"The 'variable' attribute of an EventAssignment indicates the element\n"
		"which the results of the 'math' are to be applied upon Event\n"
		"execution.\n"
		"\n"
		"Returns the variable of this EventAssignment.\n"
		"\n"
		"See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),\n"
		"unsetIdAttribute(), getVariable().\n"
		"\n"
		""},
	 { "EventAssignment_renameSIdRefs", _wrap_EventAssignment_renameSIdRefs, METH_VARARGS, "\n"
		"EventAssignment_renameSIdRefs(EventAssignment self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "EventAssignment_renameUnitSIdRefs", _wrap_EventAssignment_renameUnitSIdRefs, METH_VARARGS, "\n"
		"EventAssignment_renameUnitSIdRefs(EventAssignment self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "EventAssignment_replaceSIDWithFunction", _wrap_EventAssignment_replaceSIDWithFunction, METH_VARARGS, "\n"
		"EventAssignment_replaceSIDWithFunction(EventAssignment self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "EventAssignment_divideAssignmentsToSIdByFunction", _wrap_EventAssignment_divideAssignmentsToSIdByFunction, METH_VARARGS, "\n"
		"EventAssignment_divideAssignmentsToSIdByFunction(EventAssignment self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "EventAssignment_multiplyAssignmentsToSIdByFunction", _wrap_EventAssignment_multiplyAssignmentsToSIdByFunction, METH_VARARGS, "\n"
		"EventAssignment_multiplyAssignmentsToSIdByFunction(EventAssignment self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "EventAssignment_swigregister", EventAssignment_swigregister, METH_O, NULL},
	 { "EventAssignment_swiginit", EventAssignment_swiginit, METH_VARARGS, NULL},
	 { "new_ListOfEventAssignments", _wrap_new_ListOfEventAssignments, METH_VARARGS, "\n"
		"ListOfEventAssignments(unsigned int level, unsigned int version)\n"
		"new_ListOfEventAssignments(SBMLNamespaces sbmlns) -> ListOfEventAssignments\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfEventAssignments(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new ListOfEventAssignments object.\n"
		"\n"
		"The object is constructed such that it is valid for the SBML Level and\n"
		"Version combination determined by the SBMLNamespaces object in\n"
		"'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object that is used to\n"
		"determine the characteristics of the ListOfEventAssignments object to\n"
		"be created.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ListOfEventAssignments(long level, long version)\n"
		"\n"
		"Creates a new ListOfEventAssignments object.\n"
		"\n"
		"The object is constructed such that it is valid for the given SBML\n"
		"Level and Version combination.\n"
		"\n"
		"Parameter 'level' is the SBML Level.\n"
		"\n"
		"Parameter 'version' is the Version within the SBML Level.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		""},
	 { "ListOfEventAssignments_clone", _wrap_ListOfEventAssignments_clone, METH_O, "\n"
		"ListOfEventAssignments_clone(ListOfEventAssignments self) -> ListOfEventAssignments\n"
		"\n"
		"Creates and returns a deep copy of this ListOfEventAssignments object.\n"
		"\n"
		"Returns the (deep) copy of this ListOfEventAssignments object.\n"
		"\n"
		""},
	 { "ListOfEventAssignments_getItemTypeCode", _wrap_ListOfEventAssignments_getItemTypeCode, METH_O, "\n"
		"ListOfEventAssignments_getItemTypeCode(ListOfEventAssignments self) -> int\n"
		"\n"
		"Returns the libSBML type code for the objects contained in this ListOf\n"
		"(i.e., EventAssignment objects, if the list is non-empty).\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for the objects contained in this ListOf:\n"
		"SBML_EVENT_ASSIGNMENT (default).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "ListOfEventAssignments_getElementName", _wrap_ListOfEventAssignments_getElementName, METH_O, "\n"
		"ListOfEventAssignments_getElementName(ListOfEventAssignments self) -> string\n"
		"\n"
		"Returns the XML element name of this object.\n"
		"\n"
		"For ListOfEventAssignments, the XML element name is\n"
		"''listOfEventAssignments'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''listOfEventAssignments'.'\n"
		"\n"
		""},
	 { "ListOfEventAssignments_get", _wrap_ListOfEventAssignments_get, METH_VARARGS, "\n"
		"ListOfEventAssignments_get(ListOfEventAssignments self, unsigned int n) -> EventAssignment\n"
		"ListOfEventAssignments_get(ListOfEventAssignments self, unsigned int n) -> EventAssignment\n"
		"ListOfEventAssignments_get(ListOfEventAssignments self, string sid) -> EventAssignment\n"
		"ListOfEventAssignments_get(ListOfEventAssignments self, string sid) -> EventAssignment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(long n)\n"
		"\n"
		"Get a EventAssignment from the ListOfEventAssignments.\n"
		"\n"
		"Parameter 'n' is the index number of the EventAssignment to get.\n"
		"\n"
		"Returns the nth EventAssignment in this ListOfEventAssignments. If the\n"
		"index 'n' is invalid, 'None' is returned.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    get(string sid)\n"
		"\n"
		"Get a EventAssignment from the ListOfEventAssignments based on its\n"
		"identifier.\n"
		"\n"
		"Parameter 'sid' is a string representing the identifier  of the\n"
		"EventAssignment to get.\n"
		"\n"
		"Returns EventAssignment in this ListOfEventAssignments with the given\n"
		"'sid' or 'None' if no such EventAssignment exists.\n"
		"\n"
		"See also get(), size().\n"
		"\n"
		""},
	 { "ListOfEventAssignments_remove", _wrap_ListOfEventAssignments_remove, METH_VARARGS, "\n"
		"ListOfEventAssignments_remove(ListOfEventAssignments self, unsigned int n) -> EventAssignment\n"
		"ListOfEventAssignments_remove(ListOfEventAssignments self, string sid) -> EventAssignment\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(long n)\n"
		"\n"
		"Removes the nth item from this ListOfEventAssignments items and\n"
		"returns a pointer to it.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"\n"
		"Parameter 'n' is the index of the item to remove.\n"
		"\n"
		"See also size().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string sid)\n"
		"\n"
		"Removes item in this ListOfEventAssignments items with the given\n"
		"identifier.\n"
		"\n"
		"The caller owns the returned item and is responsible for deleting it.\n"
		"If none of the items in this list have the identifier 'sid', then\n"
		"'None' is returned.\n"
		"\n"
		"Parameter 'sid' is the identifier of the item to remove.\n"
		"\n"
		"Returns the item removed.  As mentioned above, the caller owns the\n"
		"returned item.\n"
		"\n"
		""},
	 { "ListOfEventAssignments_getElementBySId", _wrap_ListOfEventAssignments_getElementBySId, METH_VARARGS, "\n"
		"ListOfEventAssignments_getElementBySId(ListOfEventAssignments self, string id) -> SBase\n"
		"\n"
		"Returns the first child element found that has the given 'id' in the\n"
		"model-wide SId namespace, or 'None' if no such object is found.\n"
		"\n"
		"Note that EventAssignments do not actually have IDs, but the libsbml\n"
		"interface pretends that they do: no event assignment is returned by\n"
		"this function.\n"
		"\n"
		"Parameter 'id' is string representing the id of the object to find.\n"
		"\n"
		"Returns pointer to the first element found with the given 'id'.\n"
		"\n"
		""},
	 { "delete_ListOfEventAssignments", _wrap_delete_ListOfEventAssignments, METH_O, "delete_ListOfEventAssignments(ListOfEventAssignments self)"},
	 { "ListOfEventAssignments_swigregister", ListOfEventAssignments_swigregister, METH_O, NULL},
	 { "ListOfEventAssignments_swiginit", ListOfEventAssignments_swiginit, METH_VARARGS, NULL},
	 { "delete_Trigger", _wrap_delete_Trigger, METH_O, "delete_Trigger(Trigger self)"},
	 { "new_Trigger", _wrap_new_Trigger, METH_VARARGS, "\n"
		"Trigger(unsigned int level, unsigned int version)\n"
		"Trigger(SBMLNamespaces sbmlns)\n"
		"new_Trigger(Trigger orig) -> Trigger\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Trigger(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new Trigger using the given SBMLNamespaces object 'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Trigger(long level, long version)\n"
		"\n"
		"Creates a new Trigger using the given SBML 'level' and 'version'\n"
		"values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"Trigger.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this Trigger.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Trigger(Trigger orig)\n"
		"\n"
		"Copy constructor; creates a copy of this Trigger.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "Trigger_clone", _wrap_Trigger_clone, METH_O, "\n"
		"Trigger_clone(Trigger self) -> Trigger\n"
		"\n"
		"Creates and returns a deep copy of this Trigger object.\n"
		"\n"
		"Returns the (deep) copy of this Trigger object.\n"
		"\n"
		""},
	 { "Trigger_getMath", _wrap_Trigger_getMath, METH_O, "\n"
		"Trigger_getMath(Trigger self) -> ASTNode\n"
		"\n"
		"Get the mathematical formula for the trigger and return it as an AST.\n"
		"\n"
		"Returns the math of this Trigger, or 'None' if the math is not set.\n"
		"\n"
		""},
	 { "Trigger_getInitialValue", _wrap_Trigger_getInitialValue, METH_O, "\n"
		"Trigger_getInitialValue(Trigger self) -> bool\n"
		"\n"
		"(SBML Level 3 only) Get the value of the 'initialValue' attribute of\n"
		"this Trigger.\n"
		"\n"
		"Returns the boolean value stored as the 'initialValue' attribute value\n"
		"in this Trigger.\n"
		"\n"
		"Note: The attribute 'initialValue' is available in SBML Level 3, but\n"
		"is not present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Trigger_getPersistent", _wrap_Trigger_getPersistent, METH_O, "\n"
		"Trigger_getPersistent(Trigger self) -> bool\n"
		"\n"
		"(SBML Level 3 only) Get the value of the 'persistent' attribute of\n"
		"this Trigger.\n"
		"\n"
		"Returns the boolean value stored as the 'persistent' attribute value\n"
		"in this Trigger.\n"
		"\n"
		"Note: The attribute 'persistent' is available in SBML Level 3, but is\n"
		"not present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Trigger_isSetMath", _wrap_Trigger_isSetMath, METH_O, "\n"
		"Trigger_isSetMath(Trigger self) -> bool\n"
		"\n"
		"Predicate to test whether the math for this trigger is set.\n"
		"\n"
		"Returns 'True' if the formula (meaning the 'math' subelement) of this\n"
		"Trigger is set, 'False' otherwise.\n"
		"\n"
		""},
	 { "Trigger_isSetInitialValue", _wrap_Trigger_isSetInitialValue, METH_O, "\n"
		"Trigger_isSetInitialValue(Trigger self) -> bool\n"
		"\n"
		"(SBML Level 3 only) Predicate to test whether the 'initialValue'\n"
		"attribute for this trigger is set.\n"
		"\n"
		"Returns 'True' if the initialValue attribute of this Trigger is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The attribute 'initialValue' is available in SBML Level 3, but\n"
		"is not present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Trigger_isSetPersistent", _wrap_Trigger_isSetPersistent, METH_O, "\n"
		"Trigger_isSetPersistent(Trigger self) -> bool\n"
		"\n"
		"(SBML Level 3 only) Predicate to test whether the 'persistent'\n"
		"attribute for this trigger is set.\n"
		"\n"
		"Returns 'True' if the persistent attribute of this Trigger is set,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The attribute 'persistent' is available in SBML Level 3, but is\n"
		"not present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Trigger_setMath", _wrap_Trigger_setMath, METH_VARARGS, "\n"
		"Trigger_setMath(Trigger self, ASTNode math) -> int\n"
		"\n"
		"Sets the trigger expression of this Trigger instance to a copy of the\n"
		"given ASTNode.\n"
		"\n"
		"Parameter 'math' is an ASTNode representing a formula tree.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "Trigger_setInitialValue", _wrap_Trigger_setInitialValue, METH_VARARGS, "\n"
		"Trigger_setInitialValue(Trigger self, bool initialValue) -> int\n"
		"\n"
		"(SBML Level 3 only) Sets the 'initialValue' attribute of this Trigger\n"
		"instance.\n"
		"\n"
		"Parameter 'initialValue' is a boolean representing the initialValue to\n"
		"be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The attribute 'initialValue' is available in SBML Level 3, but\n"
		"is not present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Trigger_setPersistent", _wrap_Trigger_setPersistent, METH_VARARGS, "\n"
		"Trigger_setPersistent(Trigger self, bool persistent) -> int\n"
		"\n"
		"(SBML Level 3 only) Sets the 'persistent' attribute of this Trigger\n"
		"instance.\n"
		"\n"
		"Parameter 'persistent' is a boolean representing the persistent value\n"
		"to be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The attribute 'persistent' is available in SBML Level 3, but is\n"
		"not present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Trigger_unsetInitialValue", _wrap_Trigger_unsetInitialValue, METH_O, "\n"
		"Trigger_unsetInitialValue(Trigger self) -> int\n"
		"\n"
		"(SBML Level 3 only) Unsets the 'initialValue' attribute of this\n"
		"Trigger instance.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The attribute 'initialValue' is available in SBML Level 3, but\n"
		"is not present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Trigger_unsetPersistent", _wrap_Trigger_unsetPersistent, METH_O, "\n"
		"Trigger_unsetPersistent(Trigger self) -> int\n"
		"\n"
		"(SBML Level 3 only) Unsets the 'persistent' attribute of this  Trigger\n"
		"instance.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"Note: The attribute 'persistent' is available in SBML Level 3, but is\n"
		"not present in lower Levels of SBML.\n"
		"\n"
		""},
	 { "Trigger_getTypeCode", _wrap_Trigger_getTypeCode, METH_O, "\n"
		"Trigger_getTypeCode(Trigger self) -> int\n"
		"\n"
		"Returns the libSBML type code of this object instance.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_TRIGGER (default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "Trigger_getElementName", _wrap_Trigger_getElementName, METH_O, "\n"
		"Trigger_getElementName(Trigger self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for Trigger, is\n"
		"always ''trigger'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''trigger'.'\n"
		"\n"
		""},
	 { "Trigger_renameSIdRefs", _wrap_Trigger_renameSIdRefs, METH_VARARGS, "\n"
		"Trigger_renameSIdRefs(Trigger self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Trigger_renameUnitSIdRefs", _wrap_Trigger_renameUnitSIdRefs, METH_VARARGS, "\n"
		"Trigger_renameUnitSIdRefs(Trigger self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Trigger_replaceSIDWithFunction", _wrap_Trigger_replaceSIDWithFunction, METH_VARARGS, "\n"
		"Trigger_replaceSIDWithFunction(Trigger self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Trigger_hasRequiredElements", _wrap_Trigger_hasRequiredElements, METH_O, "\n"
		"Trigger_hasRequiredElements(Trigger self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this\n"
		"Trigger object have been set.\n"
		"\n"
		"Note: The required elements for a Trigger object are:\n"
		"\n"
		"* 'math' inSBML Level 2 and Level 3 Version 1.   (In SBML Level 3\n"
		"Version 2+, it is no longer required.)\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "Trigger_hasRequiredAttributes", _wrap_Trigger_hasRequiredAttributes, METH_O, "\n"
		"Trigger_hasRequiredAttributes(Trigger self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required attributes for this\n"
		"Trigger object have been set.\n"
		"\n"
		"The required attributes for a Trigger object are:\n"
		"\n"
		"* 'persistent' (required in SBML Level 3)\n"
		"\n"
		"* 'initialValue' (required in SBML Level 3)\n"
		"\n"
		"Returns a boolean value indicating whether all the required attributes\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "Trigger_removeFromParentAndDelete", _wrap_Trigger_removeFromParentAndDelete, METH_O, "\n"
		"Trigger_removeFromParentAndDelete(Trigger self) -> int\n"
		"\n"
		"Finds this Trigger's Event parent and calls unsetTrigger() on it,\n"
		"indirectly deleting itself.  Overridden from the SBase function since\n"
		"the parent is not a ListOf.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Trigger_swigregister", Trigger_swigregister, METH_O, NULL},
	 { "Trigger_swiginit", Trigger_swiginit, METH_VARARGS, NULL},
	 { "delete_Delay", _wrap_delete_Delay, METH_O, "delete_Delay(Delay self)"},
	 { "new_Delay", _wrap_new_Delay, METH_VARARGS, "\n"
		"Delay(unsigned int level, unsigned int version)\n"
		"Delay(SBMLNamespaces sbmlns)\n"
		"new_Delay(Delay orig) -> Delay\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Delay(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new Delay using the given SBMLNamespaces object 'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Delay(long level, long version)\n"
		"\n"
		"Creates a new Delay using the given SBML 'level' and 'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"Delay.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this Delay.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Delay(Delay orig)\n"
		"\n"
		"Copy constructor; creates a copy of this Delay.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "Delay_clone", _wrap_Delay_clone, METH_O, "\n"
		"Delay_clone(Delay self) -> Delay\n"
		"\n"
		"Creates and returns a deep copy of this Delay object.\n"
		"\n"
		"Returns the (deep) copy of this Delay object.\n"
		"\n"
		""},
	 { "Delay_getMath", _wrap_Delay_getMath, METH_O, "\n"
		"Delay_getMath(Delay self) -> ASTNode\n"
		"\n"
		"Get the mathematical formula for the delay and return it as an AST.\n"
		"\n"
		"Returns the math of this Delay, or 'None' if the math is not set.\n"
		"\n"
		""},
	 { "Delay_isSetMath", _wrap_Delay_isSetMath, METH_O, "\n"
		"Delay_isSetMath(Delay self) -> bool\n"
		"\n"
		"Predicate to test whether the formula for this delay is set.\n"
		"\n"
		"Returns 'True' if the formula (meaning the 'math' subelement) of this\n"
		"Delay is set, 'False' otherwise.\n"
		"\n"
		""},
	 { "Delay_setMath", _wrap_Delay_setMath, METH_VARARGS, "\n"
		"Delay_setMath(Delay self, ASTNode math) -> int\n"
		"\n"
		"Sets the delay expression of this Delay instance to a copy of the\n"
		"given ASTNode.\n"
		"\n"
		"Parameter 'math' is an ASTNode representing a formula tree.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "Delay_getDerivedUnitDefinition", _wrap_Delay_getDerivedUnitDefinition, METH_VARARGS, "\n"
		"Delay_getDerivedUnitDefinition(Delay self) -> UnitDefinition\n"
		"Delay_getDerivedUnitDefinition(Delay self) -> UnitDefinition\n"
		"\n"
		"Calculates and returns a UnitDefinition that expresses the units of\n"
		"measurement assumed for the 'math' expression of this Delay.\n"
		"\n"
		"Delay elements in SBML express a time delay for an Event.  Beginning\n"
		"with SBML Level 2 Version 2, the units of that time are calculated\n"
		"based on the mathematical expression and the model quantities\n"
		"referenced by <ci> elements used within that expression.  (In SBML\n"
		"Level 2 Version 1, there exists an attribute on Event called\n"
		"'timeUnits'.  This attribute can be used to set the units of the Delay\n"
		"expression explicitly.)  The method Delay.getDerivedUnitDefinition()\n"
		"returns what libSBML computes the units to be, to the extent that\n"
		"libSBML can compute them.\n"
		"\n"
		"Note: The functionality that facilitates unit analysis depends on the\n"
		"model as a whole.  Thus, in cases where the object has not been added\n"
		"to a model or the model itself is incomplete, unit analysis is not\n"
		"possible and this method will return 'None.'\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Note that it is possible the 'math' expression in the Delay contains\n"
		"literal numbers or parameters with undeclared units.  In those cases,\n"
		"it is not possible to calculate the units of the overall expression\n"
		"without making assumptions.  LibSBML does not make assumptions about\n"
		"the units, and Delay.getDerivedUnitDefinition() only returns the units\n"
		"as far as it is able to determine them.  For example, in an expression\n"
		"X + Y, if X has unambiguously-defined units and Y does not, it will\n"
		"return the units of X.  When using this method, it is critical that\n"
		"callers also invoke the method Delay.containsUndeclaredUnits() to\n"
		"determine whether this situation holds.  Callers should take suitable\n"
		"action in those situations.\n"
		"\n"
		"Returns a UnitDefinition that expresses the units of the math\n"
		"expression of this Delay, or 'None' if one cannot be constructed.\n"
		"\n"
		"See also containsUndeclaredUnits().\n"
		"\n"
		""},
	 { "Delay_containsUndeclaredUnits", _wrap_Delay_containsUndeclaredUnits, METH_VARARGS, "\n"
		"Delay_containsUndeclaredUnits(Delay self) -> bool\n"
		"Delay_containsUndeclaredUnits(Delay self) -> bool\n"
		"\n"
		"Predicate returning 'True' if the 'math' expression in this Delay\n"
		"instance contains parameters with undeclared units or literal numbers.\n"
		"\n"
		"Delay elements in SBML express a time delay for an Event.  Beginning\n"
		"with SBML Level 2 Version 2, the units of that time are calculated\n"
		"based on the mathematical expression and the model quantities\n"
		"referenced by <ci> elements used within that expression.  (In SBML\n"
		"Level 2 Version 1, there exists an attribute on Event called\n"
		"'timeUnits'.  This attribute can be used to set the units of the Delay\n"
		"expression explicitly.)  The method Delay.getDerivedUnitDefinition()\n"
		"returns what libSBML computes the units to be, to the extent that\n"
		"libSBML can compute them.\n"
		"\n"
		"If the expression contains literal numbers or parameters with\n"
		"undeclared units, libSBML may not be able to compute the full units of\n"
		"the expression and will only return what it can compute.  Callers\n"
		"should always use Delay.containsUndeclaredUnits() when using\n"
		"Delay.getDerivedUnitDefinition() to decide whether the returned units\n"
		"may be incomplete.\n"
		"\n"
		"Returns 'True' if the math expression of this Delay includes\n"
		"numbers/parameters with undeclared units, 'False' otherwise.\n"
		"\n"
		"Note: A return value of 'True' indicates that the UnitDefinition\n"
		"returned by Delay.getDerivedUnitDefinition() may not accurately\n"
		"represent the units of the expression.\n"
		"\n"
		"See also getDerivedUnitDefinition().\n"
		"\n"
		""},
	 { "Delay_getTypeCode", _wrap_Delay_getTypeCode, METH_O, "\n"
		"Delay_getTypeCode(Delay self) -> int\n"
		"\n"
		"Returns the libSBML type code of this object instance.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_DELAY (default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "Delay_getElementName", _wrap_Delay_getElementName, METH_O, "\n"
		"Delay_getElementName(Delay self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for Delay, is\n"
		"always ''delay'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''delay'.'\n"
		"\n"
		"See also getTypeCode().\n"
		"\n"
		""},
	 { "Delay_hasRequiredElements", _wrap_Delay_hasRequiredElements, METH_O, "\n"
		"Delay_hasRequiredElements(Delay self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this Delay\n"
		"object have been set.\n"
		"\n"
		"Note: The required elements for a Delay object are:\n"
		"\n"
		"* 'math' inSBML Level 2 and Level 3 Version 1.   (In SBML Level 3\n"
		"Version 2+, it is no longer required.)\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "Delay_removeFromParentAndDelete", _wrap_Delay_removeFromParentAndDelete, METH_O, "\n"
		"Delay_removeFromParentAndDelete(Delay self) -> int\n"
		"\n"
		"Finds this Delay's Event parent and calls unsetDelay() on it,\n"
		"indirectly deleting itself.\n"
		"\n"
		"Overridden from the SBase function since the parent is not a ListOf.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Delay_renameSIdRefs", _wrap_Delay_renameSIdRefs, METH_VARARGS, "\n"
		"Delay_renameSIdRefs(Delay self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Delay_renameUnitSIdRefs", _wrap_Delay_renameUnitSIdRefs, METH_VARARGS, "\n"
		"Delay_renameUnitSIdRefs(Delay self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Delay_replaceSIDWithFunction", _wrap_Delay_replaceSIDWithFunction, METH_VARARGS, "\n"
		"Delay_replaceSIDWithFunction(Delay self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Delay_swigregister", Delay_swigregister, METH_O, NULL},
	 { "Delay_swiginit", Delay_swiginit, METH_VARARGS, NULL},
	 { "delete_Priority", _wrap_delete_Priority, METH_O, "delete_Priority(Priority self)"},
	 { "new_Priority", _wrap_new_Priority, METH_VARARGS, "\n"
		"Priority(unsigned int level, unsigned int version)\n"
		"Priority(SBMLNamespaces sbmlns)\n"
		"new_Priority(Priority orig) -> Priority\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Priority(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new Priority object using the given SBMLNamespaces object\n"
		"'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"Note: The Priority construct exists only in SBML Level 3; it cannot be\n"
		"used in SBML Level 2 or Level 1 models.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Priority(long level, long version)\n"
		"\n"
		"Creates a new Priority object using the given SBML 'level' and\n"
		"'version' values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"Priority.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this Priority.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"Note: The Priority construct exists only in SBML Level 3; it cannot be\n"
		"used in SBML Level 2 or Level 1 models.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Priority(Priority orig)\n"
		"\n"
		"Copy constructor; creates a copy of this Priority.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "Priority_clone", _wrap_Priority_clone, METH_O, "\n"
		"Priority_clone(Priority self) -> Priority\n"
		"\n"
		"Creates and returns a deep copy of this Priority object.\n"
		"\n"
		"Returns the (deep) copy of this Priority object.\n"
		"\n"
		""},
	 { "Priority_getMath", _wrap_Priority_getMath, METH_O, "\n"
		"Priority_getMath(Priority self) -> ASTNode\n"
		"\n"
		"Get the mathematical formula for the priority and return it as an AST.\n"
		"\n"
		"Returns the math of this Priority, or 'None' if the math is not set.\n"
		"\n"
		""},
	 { "Priority_isSetMath", _wrap_Priority_isSetMath, METH_O, "\n"
		"Priority_isSetMath(Priority self) -> bool\n"
		"\n"
		"Predicate to test whether the formula for this delay is set.\n"
		"\n"
		"Returns 'True' if the formula (meaning the 'math' subelement) of this\n"
		"Priority is set, 'False' otherwise.\n"
		"\n"
		""},
	 { "Priority_setMath", _wrap_Priority_setMath, METH_VARARGS, "\n"
		"Priority_setMath(Priority self, ASTNode math) -> int\n"
		"\n"
		"Sets the math expression of this Priority instance to a copy of the\n"
		"given ASTNode.\n"
		"\n"
		"Parameter 'math' is an ASTNode representing a formula tree.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "Priority_getTypeCode", _wrap_Priority_getTypeCode, METH_O, "\n"
		"Priority_getTypeCode(Priority self) -> int\n"
		"\n"
		"Returns the libSBML type code of this object instance.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_PRIORITY (default).\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "Priority_getElementName", _wrap_Priority_getElementName, METH_O, "\n"
		"Priority_getElementName(Priority self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for Priority, is\n"
		"always ''priority'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''priority'.'\n"
		"\n"
		"See also getTypeCode().\n"
		"\n"
		""},
	 { "Priority_hasRequiredElements", _wrap_Priority_hasRequiredElements, METH_O, "\n"
		"Priority_hasRequiredElements(Priority self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this\n"
		"Priority object have been set.\n"
		"\n"
		"Note: The required elements for a Priority object are:\n"
		"\n"
		"* 'math' inSBML Level 2 and Level 3 Version 1.   (In SBML Level 3\n"
		"Version 2+, it is no longer required.)\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "Priority_removeFromParentAndDelete", _wrap_Priority_removeFromParentAndDelete, METH_O, "\n"
		"Priority_removeFromParentAndDelete(Priority self) -> int\n"
		"\n"
		"Finds this Priority's Event parent and calls unsetPriority() on it,\n"
		"indirectly deleting itself.\n"
		"\n"
		"Overridden from the SBase function since the parent is not a ListOf.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "Priority_renameSIdRefs", _wrap_Priority_renameSIdRefs, METH_VARARGS, "\n"
		"Priority_renameSIdRefs(Priority self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Priority_renameUnitSIdRefs", _wrap_Priority_renameUnitSIdRefs, METH_VARARGS, "\n"
		"Priority_renameUnitSIdRefs(Priority self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "Priority_replaceSIDWithFunction", _wrap_Priority_replaceSIDWithFunction, METH_VARARGS, "\n"
		"Priority_replaceSIDWithFunction(Priority self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Priority_swigregister", Priority_swigregister, METH_O, NULL},
	 { "Priority_swiginit", Priority_swiginit, METH_VARARGS, NULL},
	 { "SBO_isQuantitativeParameter", _wrap_SBO_isQuantitativeParameter, METH_O, "\n"
		"SBO_isQuantitativeParameter(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Note: The 'quantitative parameter' SBO term is now known as 'systems\n"
		"description parameter'.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'quantiative parameter', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isParticipantRole", _wrap_SBO_isParticipantRole, METH_O, "\n"
		"SBO_isParticipantRole(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'participant role', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isModellingFramework", _wrap_SBO_isModellingFramework, METH_O, "\n"
		"SBO_isModellingFramework(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'modeling framework', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isMathematicalExpression", _wrap_SBO_isMathematicalExpression, METH_O, "\n"
		"SBO_isMathematicalExpression(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'mathematical expression', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isKineticConstant", _wrap_SBO_isKineticConstant, METH_O, "\n"
		"SBO_isKineticConstant(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'kinetic constant', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isReactant", _wrap_SBO_isReactant, METH_O, "\n"
		"SBO_isReactant(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'reactant', 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isProduct", _wrap_SBO_isProduct, METH_O, "\n"
		"SBO_isProduct(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'product', 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isModifier", _wrap_SBO_isModifier, METH_O, "\n"
		"SBO_isModifier(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'modifier', 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isRateLaw", _wrap_SBO_isRateLaw, METH_O, "\n"
		"SBO_isRateLaw(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'rate law', 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isEvent", _wrap_SBO_isEvent, METH_O, "\n"
		"SBO_isEvent(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'event', 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isPhysicalParticipant", _wrap_SBO_isPhysicalParticipant, METH_O, "\n"
		"SBO_isPhysicalParticipant(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'physical participant, 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isParticipant", _wrap_SBO_isParticipant, METH_O, "\n"
		"SBO_isParticipant(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'participant', 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isInteraction", _wrap_SBO_isInteraction, METH_O, "\n"
		"SBO_isInteraction(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Note: The 'interaction' SBO term is now known as 'occurring entity\n"
		"representation'.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'interaction', 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isEntity", _wrap_SBO_isEntity, METH_O, "\n"
		"SBO_isEntity(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Note: The 'entity' SBO term is now known as 'physical entity\n"
		"representation'.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'entity', 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isFunctionalEntity", _wrap_SBO_isFunctionalEntity, METH_O, "\n"
		"SBO_isFunctionalEntity(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'functional entity', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isMaterialEntity", _wrap_SBO_isMaterialEntity, METH_O, "\n"
		"SBO_isMaterialEntity(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'material entity', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isConservationLaw", _wrap_SBO_isConservationLaw, METH_O, "\n"
		"SBO_isConservationLaw(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'conservation law', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isSteadyStateExpression", _wrap_SBO_isSteadyStateExpression, METH_O, "\n"
		"SBO_isSteadyStateExpression(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'steady state expression', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isFunctionalCompartment", _wrap_SBO_isFunctionalCompartment, METH_O, "\n"
		"SBO_isFunctionalCompartment(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'functional compartment', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isContinuousFramework", _wrap_SBO_isContinuousFramework, METH_O, "\n"
		"SBO_isContinuousFramework(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'continuous framework', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isDiscreteFramework", _wrap_SBO_isDiscreteFramework, METH_O, "\n"
		"SBO_isDiscreteFramework(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'discrete framework', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isLogicalFramework", _wrap_SBO_isLogicalFramework, METH_O, "\n"
		"SBO_isLogicalFramework(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'logical framework', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isMetadataRepresentation", _wrap_SBO_isMetadataRepresentation, METH_O, "\n"
		"SBO_isMetadataRepresentation(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'metadata representation', 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isOccurringEntityRepresentation", _wrap_SBO_isOccurringEntityRepresentation, METH_O, "\n"
		"SBO_isOccurringEntityRepresentation(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'occurring entity representation',\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isPhysicalEntityRepresentation", _wrap_SBO_isPhysicalEntityRepresentation, METH_O, "\n"
		"SBO_isPhysicalEntityRepresentation(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'physical entity representation',\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isSystemsDescriptionParameter", _wrap_SBO_isSystemsDescriptionParameter, METH_O, "\n"
		"SBO_isSystemsDescriptionParameter(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'systems description parameter',\n"
		"'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isQuantitativeSystemsDescriptionParameter", _wrap_SBO_isQuantitativeSystemsDescriptionParameter, METH_O, "\n"
		"SBO_isQuantitativeSystemsDescriptionParameter(unsigned int term) -> bool\n"
		"\n"
		"Returns 'True' if the given term identifier comes from the stated\n"
		"branch of SBO.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'quantiative systems description\n"
		"parameter', 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_isObselete", _wrap_SBO_isObselete, METH_O, "\n"
		"SBO_isObselete(unsigned int term) -> bool\n"
		"\n"
		"Predicate for checking whether the given term is obsolete.\n"
		"\n"
		"Returns 'True' if 'term' is-a SBO 'obsolete' term, 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_intToString", _wrap_SBO_intToString, METH_O, "\n"
		"SBO_intToString(int sboTerm) -> string\n"
		"\n"
		"Returns the integer as a correctly formatted SBO identifier string.\n"
		"\n"
		"Returns the given integer sboTerm as a zero-padded seven digit string.\n"
		"\n"
		"Note: If the sboTerm is not in the correct range (0000000-9999999), an\n"
		"empty string is returned.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_stringToInt", _wrap_SBO_stringToInt, METH_O, "\n"
		"SBO_stringToInt(string sboTerm) -> int\n"
		"\n"
		"Returns the string as a correctly formatted SBO integer portion.\n"
		"\n"
		"Returns the given string sboTerm as an integer.  If the sboTerm is not\n"
		"in the correct format (a zero-padded, seven digit string), -1 is\n"
		"returned.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_checkTerm", _wrap_SBO_checkTerm, METH_VARARGS, "\n"
		"SBO_checkTerm(string sboTerm) -> bool\n"
		"SBO_checkTerm(int sboTerm) -> bool\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    checkTerm(string sboTerm)\n"
		"\n"
		"Checks the format of the given SBO identifier string.\n"
		"\n"
		"Returns 'True' if sboTerm is in the correct format (a zero-padded,\n"
		"seven digit string), 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    checkTerm(int sboTerm)\n"
		"\n"
		"Checks the format of the given SBO identifier, given in the form of\n"
		"the integer portion alone.\n"
		"\n"
		"Returns 'True' if sboTerm is in the range (0000000-9999999), 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBO_getParentBranch", _wrap_SBO_getParentBranch, METH_O, "\n"
		"SBO_getParentBranch(unsigned int term) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SBO", _wrap_new_SBO, METH_NOARGS, "\n"
		"new_SBO() -> SBO\n"
		"\n"
		"@internal\n"
		"\n"
		""},
	 { "delete_SBO", _wrap_delete_SBO, METH_O, "delete_SBO(SBO self)"},
	 { "SBO_swigregister", SBO_swigregister, METH_O, NULL},
	 { "SBO_swiginit", SBO_swiginit, METH_VARARGS, NULL},
	 { "SyntaxChecker_isValidSBMLSId", _wrap_SyntaxChecker_isValidSBMLSId, METH_O, "\n"
		"SyntaxChecker_isValidSBMLSId(string sid) -> bool\n"
		"\n"
		"Returns 'True' or 'False' depending on whether the argument string\n"
		"conforms to the syntax of SBML identifiers.\n"
		"\n"
		"In SBML, identifiers that are the values of 'id' attributes on\n"
		"objects must conform to a data type called SId in the SBML\n"
		"specifications.  LibSBML does not provide an explicit SId data type;\n"
		"it uses ordinary character strings, which is easier for applications\n"
		"to support.  (LibSBML does, however, test for identifier validity at\n"
		"various times, such as when reading in models from files and data\n"
		"streams.)\n"
		"\n"
		"This method provides programs with the ability to test explicitly that\n"
		"the identifier strings they create conform to the SBML identifier\n"
		"syntax.\n"
		"\n"
		"Parameter 'sid' is string to be checked for conformance to SBML\n"
		"identifier syntax.\n"
		"\n"
		"Returns 'True' if the string conforms to type SBML data type SId,\n"
		"'False' otherwise.\n"
		"\n"
		"The identifier given by an object's 'id' attribute value is used to\n"
		"identify the object within the SBML model definition. Other objects\n"
		"can refer to the component using this identifier.  The data type of\n"
		"'id' is always SId or a type derived from that, such as UnitSId,\n"
		"depending on the object in  question.  All data types are defined as\n"
		"follows:\n"
		"\n"
		"  letter ::= 'a'..'z','A'..'Z'\n"
		"  digit  ::= '0'..'9'\n"
		"  idChar ::= letter | digit | '_'\n"
		"  SId    ::= ( letter | '_' ) idChar*\n"
		"\n"
		"The equality of SId and SId-derived values in SBML is determined by\n"
		"an exact character sequence match; i.e., comparisons of these\n"
		"identifiers must be performed in a case-sensitive manner.  This\n"
		"applies to all uses of SId,  SIdRef, and derived types.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also SyntaxChecker.isValidUnitSId() , SyntaxChecker.isValidXMLID()\n"
		".\n"
		"\n"
		""},
	 { "SyntaxChecker_isValidXMLID", _wrap_SyntaxChecker_isValidXMLID, METH_O, "\n"
		"SyntaxChecker_isValidXMLID(string id) -> bool\n"
		"\n"
		"Returns 'True' or 'False' depending on whether the argument string\n"
		"conforms to the XML data type ID.\n"
		"\n"
		"The optional attribute named 'metaid', present on every major SBML\n"
		"component type, is for supporting metadata annotations using RDF\n"
		"(Resource Description Format).  The attribute value has the data type\n"
		"XML ID, the XML identifier type, which means each 'metaid' value must\n"
		"be globally unique within an SBML file.  The latter point is\n"
		"important, because the uniqueness criterion applies across any\n"
		"attribute with type ID anywhere in the file, not just the 'metaid'\n"
		"attribute used by SBML---something to be aware of if your application-\n"
		"specific XML content inside the 'annotation' subelement happens to use\n"
		"the XML ID type.  Although SBML itself specifies the use of XML ID\n"
		"only for the 'metaid' attribute, SBML-compatible applications should\n"
		"be careful if they use XML ID's in XML portions of a model that are\n"
		"not defined by SBML, such as in the application-specific content of\n"
		"the 'annotation' subelement.  Finally, note that LibSBML does not\n"
		"provide an explicit XML ID data type; it uses ordinary character\n"
		"strings, which is easier for applications to support.\n"
		"\n"
		"This method provides programs with the ability to test explicitly that\n"
		"the identifier strings they create conform to the SBML identifier\n"
		"syntax.\n"
		"\n"
		"Parameter 'id' is string to be checked for conformance to the syntax\n"
		"of XML ID.\n"
		"\n"
		"Returns 'True' if the string is a syntactically-valid value for the\n"
		"XML type ID, 'False' otherwise.\n"
		"\n"
		"Note: The following is a summary of the definition of the XML 1.0 data\n"
		"type ID.  We express the syntax using an extended form of BNF\n"
		"notation: <p> <nobr>NCNameChar ::= letter | digit | '.' | '-' | '_' |\n"
		"':' | CombiningChar | Extender </nobr> ID ::= ( letter | '_' | ':' )\n"
		"NCNameChar* <p> The characters ( and ) are used for grouping, the\n"
		"character * means \"zero or more times\", and the character |\n"
		"indicates logical \"or\". The production letter consists of the basic\n"
		"upper and lower case alphabetic characters of the Latin alphabet along\n"
		"with a large number of related characters defined by Unicode 2.0;\n"
		"similarly, the production digit consists of the numerals 0..9 along\n"
		"with related Unicode 2.0 characters.  The CombiningChar production is\n"
		"a list of characters that add such things as accents to the preceding\n"
		"character. (For example, the Unicode character \\#x030A when combined\n"
		"with a produces a.)  The Extender production is a list of characters\n"
		"that extend the shape of the preceding character.  Please consult the\n"
		"XML 1.0 specification for the complete definitions of letter, digit,\n"
		"CombiningChar, and Extender. <p>\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also SyntaxChecker.isValidSBMLSId() ,\n"
		"SyntaxChecker.isValidUnitSId() .\n"
		"\n"
		""},
	 { "SyntaxChecker_isValidXMLanyURI", _wrap_SyntaxChecker_isValidXMLanyURI, METH_O, "\n"
		"SyntaxChecker_isValidXMLanyURI(string uri) -> bool\n"
		"\n"
		"Returns 'True' or 'False' depending on whether the 'uri' argument\n"
		"string conforms to the XML data type anyURI.\n"
		"\n"
		"Type anyURI is defined by XML Schema 1.0. It is a character string\n"
		"data type whose values are interpretable as URIs (Universal Resource\n"
		"Identifiers) as described by the W3C document RFC 3986.  LibSBML does\n"
		"not provide an explicit XML anyURI data type; it uses ordinary\n"
		"character strings, which is easier for applications to support.\n"
		"LibSBML does, however, test for anyURI validity at various times, such\n"
		"as when reading in models from files and data streams.\n"
		"\n"
		"This method provides programs with the ability to test explicitly that\n"
		"the strings they create conform to the XML anyURI syntax.\n"
		"\n"
		"Parameter 'uri' is string to be checked for conformance to the syntax\n"
		"of anyURI.\n"
		"\n"
		"Returns 'True' if the string is a syntactically-valid value for the\n"
		"XML type anyURI,  'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SyntaxChecker_isValidUnitSId", _wrap_SyntaxChecker_isValidUnitSId, METH_O, "\n"
		"SyntaxChecker_isValidUnitSId(string units) -> bool\n"
		"\n"
		"Returns 'True' or 'False' depending on whether the argument string\n"
		"conforms to the syntax of SBML unit identifiers.\n"
		"\n"
		"In SBML, the identifiers of units (of both the predefined units and\n"
		"user-defined units) must conform to a data type called UnitSId in the\n"
		"SBML specifications.  LibSBML does not provide an explicit UnitSId\n"
		"data type; it uses ordinary character strings, which is easier for\n"
		"applications to support. LibSBML does, however, test for identifier\n"
		"validity at various times, such as when reading in models from files\n"
		"and data streams.\n"
		"\n"
		"This method provides programs with the ability to test explicitly that\n"
		"the identifier strings they create conform to the SBML identifier\n"
		"syntax.\n"
		"\n"
		"Parameter 'units' is string to be checked for conformance to SBML unit\n"
		"identifier syntax.\n"
		"\n"
		"Returns 'True' if the string conforms to type SBML data type UnitSId,\n"
		"'False' otherwise.\n"
		"\n"
		"Note: The following is a summary of the definition of the SBML\n"
		"identifier type UnitSId, which defines the permitted syntax of\n"
		"identifiers. We express the syntax using an extended form of BNF\n"
		"notation: <p> letter ::= 'a'..'z','A'..'Z' digit  ::= '0'..'9' idChar\n"
		"::= letter | digit | '_' SId    ::= ( letter | '_' ) idChar* <p> The\n"
		"characters ( and ) are used for grouping, the character * \"zero or\n"
		"more times\", and the character | indicates logical \"or\".  The\n"
		"equality of SBML unit identifiers is determined by an exact character\n"
		"sequence match; i.e., comparisons must be performed in a case-\n"
		"sensitive manner.  In addition, there are a few conditions for the\n"
		"uniqueness of unit identifiers in an SBML model.  Please consult the\n"
		"SBML specifications for the exact formulations. <p>\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also SyntaxChecker.isValidSBMLSId() , SyntaxChecker.isValidXMLID()\n"
		".\n"
		"\n"
		""},
	 { "SyntaxChecker_hasExpectedXHTMLSyntax", _wrap_SyntaxChecker_hasExpectedXHTMLSyntax, METH_VARARGS, "\n"
		"SyntaxChecker_hasExpectedXHTMLSyntax(XMLNode xhtml, SBMLNamespaces sbmlns=None) -> bool\n"
		"\n"
		"Returns 'True' or 'False' depending on whether the given XMLNode\n"
		"object contains valid XHTML content.\n"
		"\n"
		"The optional SBML element named 'notes', present on every major SBML\n"
		"component type (and in SBML Level 3, the 'message' subelement of\n"
		"Constraint), is intended as a place for storing optional information\n"
		"intended to be seen by humans.  An example use of the 'notes' element\n"
		"would be to contain formatted user comments about the model element in\n"
		"which the 'notes' element is enclosed.  Every object derived directly\n"
		"or indirectly from type SBase can have a separate value for 'notes',\n"
		"allowing users considerable freedom when adding comments to their\n"
		"models.\n"
		"\n"
		"The format of 'notes' elements conform to the definition of XHTML 1.0.\n"
		"However, the content cannot be entirely free-form; it must satisfy\n"
		"certain requirements defined in the SBML specifications for specific\n"
		"SBML Levels.  To help verify the formatting of 'notes' content,\n"
		"libSBML provides the static utility method\n"
		"SyntaxChecker.hasExpectedXHTMLSyntax(); this method implements a\n"
		"verification process that lets callers check whether the content of a\n"
		"given XMLNode object conforms to the SBML requirements for 'notes' and\n"
		"'message' structure.  Developers are urged to consult the appropriate\n"
		"SBML specification document for the Level and Version of their model\n"
		"for more in-depth explanations of using 'notes' in SBML.  The SBML\n"
		"Level 2 and 3 specifications have considerable detail about how\n"
		"'notes' element content must be structured.\n"
		"\n"
		"An aspect of XHTML validity is that the content is declared to be in\n"
		"the XML namespace for XHTML 1.0.  There is more than one way in which\n"
		"this can be done in XML.  In particular, a model might not contain the\n"
		"declaration within the 'notes' or 'message' subelement itself, but\n"
		"might instead place the declaration on an enclosing element and use an\n"
		"XML namespace prefix within the 'notes' element to refer to it.  In\n"
		"other words, the following is valid:\n"
		"\n"
		"  <sbml xmlns='http://www.sbml.org/sbml/level2/version3' level='2' version='3'\n"
		"        xmlns:xhtml='http://www.w3.org/1999/xhtml'>\n"
		"    <model>\n"
		"      <notes>\n"
		"        <xhtml:body>\n"
		"          <xhtml:center><xhtml:h2>A Simple Mitotic Oscillator</xhtml:h2></xhtml:center>\n"
		"          <xhtml:p>A minimal cascade model for the mitotic oscillator.</xhtml:p>\n"
		"        </xhtml:body>\n"
		"      </notes>\n"
		"    ... rest of model ...\n"
		"  </sbml>\n"
		"\n"
		"Contrast the above with the following, self-contained version, which\n"
		"places the XML namespace declaration within the <notes> element\n"
		"itself:\n"
		"\n"
		"  <sbml xmlns='http://www.sbml.org/sbml/level2/version3' level='2' version='3'>\n"
		"    <model>\n"
		"      <notes>\n"
		"        <html xmlns='http://www.w3.org/1999/xhtml'>\n"
		"          <head>\n"
		"            <title/>\n"
		"          </head>\n"
		"          <body>\n"
		"            <center><h2>A Simple Mitotic Oscillator</h2></center>\n"
		"            <p>A minimal cascade model for the mitotic oscillator.</p>\n"
		"          </body>\n"
		"        </html>\n"
		"      </notes>\n"
		"    ... rest of model ...\n"
		"  </sbml>\n"
		"\n"
		"Both of the above are valid XML.  The purpose of the 'sbmlns' argument\n"
		"to this method is to allow callers to check the validity of 'notes'\n"
		"and 'message' subelements whose XML namespace declarations have been\n"
		"put elsewhere in the manner illustrated above.  Callers can can pass\n"
		"in the SBMLNamespaces object of a higher-level model component if the\n"
		"XMLNode object does not itself have the XML namespace declaration for\n"
		"XHTML 1.0.\n"
		"\n"
		"Parameter 'xhtml' is the XMLNode to be checked for conformance.\n"
		"Parameter 'sbmlns' is the SBMLNamespaces associated with the object.\n"
		"\n"
		"Returns 'True' if the XMLNode content conforms, 'False' otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SyntaxChecker_isValidInternalSId", _wrap_SyntaxChecker_isValidInternalSId, METH_O, "\n"
		"SyntaxChecker_isValidInternalSId(string sid) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SyntaxChecker_isValidInternalUnitSId", _wrap_SyntaxChecker_isValidInternalUnitSId, METH_O, "\n"
		"SyntaxChecker_isValidInternalUnitSId(string sid) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SyntaxChecker", _wrap_new_SyntaxChecker, METH_NOARGS, "\n"
		"new_SyntaxChecker() -> SyntaxChecker\n"
		"\n"
		"@internal\n"
		"\n"
		""},
	 { "delete_SyntaxChecker", _wrap_delete_SyntaxChecker, METH_O, "delete_SyntaxChecker(SyntaxChecker self)"},
	 { "SyntaxChecker_swigregister", SyntaxChecker_swigregister, METH_O, NULL},
	 { "SyntaxChecker_swiginit", SyntaxChecker_swiginit, METH_VARARGS, NULL},
	 { "delete_StoichiometryMath", _wrap_delete_StoichiometryMath, METH_O, "delete_StoichiometryMath(StoichiometryMath self)"},
	 { "new_StoichiometryMath", _wrap_new_StoichiometryMath, METH_VARARGS, "\n"
		"StoichiometryMath(unsigned int level, unsigned int version)\n"
		"StoichiometryMath(SBMLNamespaces sbmlns)\n"
		"new_StoichiometryMath(StoichiometryMath orig) -> StoichiometryMath\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    StoichiometryMath(SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new StoichiometryMath object using the given SBMLNamespaces\n"
		"object 'sbmlns'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'sbmlns' is an SBMLNamespaces object.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'sbmlns' is\n"
		"inconsistent or incompatible with this object.\n"
		"\n"
		"Note: The StoichiometryMath construct exists only in SBML Level 2. It\n"
		"is an optional construct available for defining the stoichiometries of\n"
		"reactants and products in Reaction objects.  Note that a different\n"
		"mechanism is used in SBML Level 3, where StoichiometryMath is not\n"
		"available.  Please consult the top of this libSBML StoichiometryMath\n"
		"documentation for more information about the differences between SBML\n"
		"Level 2 and 3 with respect to stoichiometries.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    StoichiometryMath(long level, long version)\n"
		"\n"
		"Creates a new StoichiometryMath object using the given SBML 'level'\n"
		"values.\n"
		"\n"
		"Parameter 'level' is a long integer, the SBML Level to assign to this\n"
		"StoichiometryMath.\n"
		"\n"
		"Parameter 'version' is a long integer, the SBML Version to assign to\n"
		"this StoichiometryMath.\n"
		"\n"
		"Throws SBMLConstructorException: Thrown if the given 'level' and\n"
		"'version' combination are invalid or if this object is incompatible\n"
		"with the given level and version.\n"
		"\n"
		"Note: The StoichiometryMath construct exists only in SBML Level 2. It\n"
		"is an optional construct available for defining the stoichiometries of\n"
		"reactants and products in Reaction objects.  Note that a different\n"
		"mechanism is used in SBML Level 3, where StoichiometryMath is not\n"
		"available.  Please consult the top of this libSBML StoichiometryMath\n"
		"documentation for more information about the differences between SBML\n"
		"Level 2 and 3 with respect to stoichiometries.\n"
		"\n"
		"Note: Attempting to add an object to an SBMLDocument having a\n"
		"different combination of SBML Level, Version and XML namespaces than\n"
		"the object itself will result in an error at the time a caller\n"
		"attempts to make the addition.  A parent object must have compatible\n"
		"Level, Version and XML namespaces.  (Strictly speaking, a parent may\n"
		"also have more XML namespaces than a child, but the reverse is not\n"
		"permitted.)  The restriction is necessary to ensure that an SBML model\n"
		"has a consistent overall structure.  This requires callers to manage\n"
		"their objects carefully, but the benefit is increased flexibility in\n"
		"how models can be created by permitting callers to create objects\n"
		"bottom-up if desired.  In situations where objects are not yet\n"
		"attached to parents (e.g., SBMLDocument), knowledge of the intented\n"
		"SBML Level and Version help libSBML determine such things as whether\n"
		"it is valid to assign a particular value to an attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    StoichiometryMath(StoichiometryMath orig)\n"
		"\n"
		"Copy constructor; creates a copy of this StoichiometryMath.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "StoichiometryMath_clone", _wrap_StoichiometryMath_clone, METH_O, "\n"
		"StoichiometryMath_clone(StoichiometryMath self) -> StoichiometryMath\n"
		"\n"
		"Creates and returns a deep copy of this StoichiometryMath object.\n"
		"\n"
		"Returns the (deep) copy of this StoichiometryMath object.\n"
		"\n"
		""},
	 { "StoichiometryMath_getMath", _wrap_StoichiometryMath_getMath, METH_O, "\n"
		"StoichiometryMath_getMath(StoichiometryMath self) -> ASTNode\n"
		"\n"
		"Retrieves the mathematical formula within this StoichiometryMath and\n"
		"return it as an AST.\n"
		"\n"
		"Returns the math of this StoichiometryMath, or 'None' if the math is\n"
		"not set.\n"
		"\n"
		"Note: The StoichiometryMath construct exists only in SBML Level 2. It\n"
		"is an optional construct available for defining the stoichiometries of\n"
		"reactants and products in Reaction objects.  Note that a different\n"
		"mechanism is used in SBML Level 3, where StoichiometryMath is not\n"
		"available.  Please consult the top of this libSBML StoichiometryMath\n"
		"documentation for more information about the differences between SBML\n"
		"Level 2 and 3 with respect to stoichiometries.\n"
		"\n"
		""},
	 { "StoichiometryMath_isSetMath", _wrap_StoichiometryMath_isSetMath, METH_O, "\n"
		"StoichiometryMath_isSetMath(StoichiometryMath self) -> bool\n"
		"\n"
		"Predicate to test whether the math for this StoichiometryMath object\n"
		"is set.\n"
		"\n"
		"Returns 'True' if the formula (meaning the 'math' subelement) of this\n"
		"StoichiometryMath is set, 'False' otherwise.\n"
		"\n"
		"Note: The StoichiometryMath construct exists only in SBML Level 2. It\n"
		"is an optional construct available for defining the stoichiometries of\n"
		"reactants and products in Reaction objects.  Note that a different\n"
		"mechanism is used in SBML Level 3, where StoichiometryMath is not\n"
		"available.  Please consult the top of this libSBML StoichiometryMath\n"
		"documentation for more information about the differences between SBML\n"
		"Level 2 and 3 with respect to stoichiometries.\n"
		"\n"
		""},
	 { "StoichiometryMath_setMath", _wrap_StoichiometryMath_setMath, METH_VARARGS, "\n"
		"StoichiometryMath_setMath(StoichiometryMath self, ASTNode math) -> int\n"
		"\n"
		"Sets the 'math' expression of this StoichiometryMath instance to a\n"
		"copy of the given ASTNode.\n"
		"\n"
		"Parameter 'math' is an ASTNode representing a formula tree.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"Note: The StoichiometryMath construct exists only in SBML Level 2. It\n"
		"is an optional construct available for defining the stoichiometries of\n"
		"reactants and products in Reaction objects.  Note that a different\n"
		"mechanism is used in SBML Level 3, where StoichiometryMath is not\n"
		"available.  Please consult the top of this libSBML StoichiometryMath\n"
		"documentation for more information about the differences between SBML\n"
		"Level 2 and 3 with respect to stoichiometries.\n"
		"\n"
		""},
	 { "StoichiometryMath_getDerivedUnitDefinition", _wrap_StoichiometryMath_getDerivedUnitDefinition, METH_VARARGS, "\n"
		"StoichiometryMath_getDerivedUnitDefinition(StoichiometryMath self) -> UnitDefinition\n"
		"StoichiometryMath_getDerivedUnitDefinition(StoichiometryMath self) -> UnitDefinition\n"
		"\n"
		"Calculates and returns a UnitDefinition object that expresses the\n"
		"units returned by the math expression in this StoichiometryMath\n"
		"object.\n"
		"\n"
		"The units are calculated based on the mathematical expression in the\n"
		"StoichiometryMath and the model quantities referenced by <ci> elements\n"
		"used within that expression.  The\n"
		"StoichiometryMath.getDerivedUnitDefinition() method returns the\n"
		"calculated units.\n"
		"\n"
		"Note that the functionality that facilitates unit analysis depends  on\n"
		"the model as a whole.  Thus, in cases where the object has not  been\n"
		"added to a model or the model itself is incomplete, unit analysis is\n"
		"not possible and this method will return 'None.'\n"
		"\n"
		"Returns a UnitDefinition that expresses the units of the math,  or\n"
		"'None' if one cannot be constructed.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Note that it is possible the 'math' expression in the\n"
		"StoichiometryMath instance contains literal numbers or parameters with\n"
		"undeclared units.  In those cases, it is not possible to calculate the\n"
		"units of the overall expression without making assumptions.  LibSBML\n"
		"does not make assumptions about the units, and\n"
		"StoichiometryMath.getDerivedUnitDefinition() only returns the units as\n"
		"far as it is able to determine them.  For example, in an expression X\n"
		"+ Y, if X has unambiguously-defined units and Y does not, it will\n"
		"return the units of X.  When using this method, it is critical that\n"
		"callers also invoke the method\n"
		"StoichiometryMath.containsUndeclaredUnits() to determine whether this\n"
		"situation holds.  Callers should take suitable action in those\n"
		"situations.\n"
		"\n"
		"See also containsUndeclaredUnits().\n"
		"\n"
		""},
	 { "StoichiometryMath_containsUndeclaredUnits", _wrap_StoichiometryMath_containsUndeclaredUnits, METH_VARARGS, "\n"
		"StoichiometryMath_containsUndeclaredUnits(StoichiometryMath self) -> bool\n"
		"StoichiometryMath_containsUndeclaredUnits(StoichiometryMath self) -> bool\n"
		"\n"
		"Predicate returning 'True' if the math expression of this\n"
		"StoichiometryMath object contains literal numbers or parameters with\n"
		"undeclared units.\n"
		"\n"
		"The StoichiometryMath.getDerivedUnitDefinition() method returns what\n"
		"libSBML computes the units of the Stoichiometry to be, to the extent\n"
		"that libSBML can compute them.  However, if the expression contains\n"
		"literal numbers or parameters with undeclared units, libSBML may not\n"
		"be able to compute the full units of the expression and will only\n"
		"return what it can compute.  Callers should always use\n"
		"StoichiometryMath.containsUndeclaredUnits() when using\n"
		"StoichiometryMath.getDerivedUnitDefinition() to decide whether the\n"
		"returned units may be incomplete.\n"
		"\n"
		"Returns 'True' if the math expression of this StoichiometryMath\n"
		"includes numbers/parameters with undeclared units, 'False' otherwise.\n"
		"\n"
		"Note: A return value of 'True' indicates that the UnitDefinition\n"
		"returned by StoichiometryMath.getDerivedUnitDefinition() may not\n"
		"accurately represent the units of the expression.\n"
		"\n"
		"See also getDerivedUnitDefinition().\n"
		"\n"
		""},
	 { "StoichiometryMath_getTypeCode", _wrap_StoichiometryMath_getTypeCode, METH_O, "\n"
		"StoichiometryMath_getTypeCode(StoichiometryMath self) -> int\n"
		"\n"
		"Returns the libSBML type code of this object instance.\n"
		"\n"
		"LibSBML attaches an identifying code to every kind of SBML object.\n"
		"These are integer constants known as SBML type codes.  The names of\n"
		"all the codes begin with the characters SBML_. In the Python language\n"
		"interface for libSBML, the type codes are defined as static integer\n"
		"constants in the interface class 'libsbml'.  Note that different Level\n"
		"3 package plug-ins may use overlapping type codes; to identify the\n"
		"package to which a given object belongs, call the\n"
		"SBase.getPackageName()\n"
		"\n"
		"method on the object.\n"
		"\n"
		"The exception to this is lists:  all SBML-style list elements have the\n"
		"type  SBML_LIST_OF, regardless of what package they  are from.\n"
		"\n"
		"Returns the SBML type code for this object: SBML_STOICHIOMETRY_MATH\n"
		"(default).\n"
		"\n"
		"WARNING:\n"
		"\n"
		"The specific integer values of the possible type codes may be reused\n"
		"by different libSBML plug-ins for SBML Level 3. packages,  To fully\n"
		"identify the correct code, it is necessary to invoke both\n"
		"getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).\n"
		"\n"
		"See also getElementName(), getPackageName().\n"
		"\n"
		""},
	 { "StoichiometryMath_getElementName", _wrap_StoichiometryMath_getElementName, METH_O, "\n"
		"StoichiometryMath_getElementName(StoichiometryMath self) -> string\n"
		"\n"
		"Returns the XML element name of this object, which for\n"
		"StoichiometryMath, is always ''stoichiometryMath'.'\n"
		"\n"
		"Returns the name of this element, i.e., ''stoichiometryMath'.'\n"
		"\n"
		""},
	 { "StoichiometryMath_hasRequiredElements", _wrap_StoichiometryMath_hasRequiredElements, METH_O, "\n"
		"StoichiometryMath_hasRequiredElements(StoichiometryMath self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this\n"
		"StoichiometryMath object have been set.\n"
		"\n"
		"Note: The required elements for a StoichiometryMath object are:\n"
		"\n"
		"* 'math'\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "StoichiometryMath_removeFromParentAndDelete", _wrap_StoichiometryMath_removeFromParentAndDelete, METH_O, "\n"
		"StoichiometryMath_removeFromParentAndDelete(StoichiometryMath self) -> int\n"
		"\n"
		"Finds this StoichiometryMath's SpeciesReference parent and calls\n"
		"unsetStoichiometryMath() on it, indirectly deleting itself.\n"
		"\n"
		"Overridden from the SBase function since the parent is not a ListOf.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "StoichiometryMath_renameSIdRefs", _wrap_StoichiometryMath_renameSIdRefs, METH_VARARGS, "\n"
		"StoichiometryMath_renameSIdRefs(StoichiometryMath self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "StoichiometryMath_renameUnitSIdRefs", _wrap_StoichiometryMath_renameUnitSIdRefs, METH_VARARGS, "\n"
		"StoichiometryMath_renameUnitSIdRefs(StoichiometryMath self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "StoichiometryMath_replaceSIDWithFunction", _wrap_StoichiometryMath_replaceSIDWithFunction, METH_VARARGS, "\n"
		"StoichiometryMath_replaceSIDWithFunction(StoichiometryMath self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "StoichiometryMath_swigregister", StoichiometryMath_swigregister, METH_O, NULL},
	 { "StoichiometryMath_swiginit", StoichiometryMath_swiginit, METH_VARARGS, NULL},
	 { "delete_SBMLNamespaces", _wrap_delete_SBMLNamespaces, METH_O, "delete_SBMLNamespaces(SBMLNamespaces self)"},
	 { "new_SBMLNamespaces", _wrap_new_SBMLNamespaces, METH_VARARGS, "\n"
		"SBMLNamespaces(unsigned int level=SBML_DEFAULT_LEVEL, unsigned int version=SBML_DEFAULT_VERSION)\n"
		"SBMLNamespaces(unsigned int level, unsigned int version, string pkgName, unsigned int pkgVersion, string pkgPrefix=\"\")\n"
		"new_SBMLNamespaces(SBMLNamespaces orig) -> SBMLNamespaces\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLNamespaces(SBMLNamespaces orig)\n"
		"\n"
		"Copy constructor; creates a copy of a SBMLNamespaces.\n"
		"\n"
		"Parameter 'orig' is the SBMLNamespaces instance to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLNamespaces(long level, long version, string &pkgName,\n"
		"long pkgVersion, string pkgPrefix = '')\n"
		"\n"
		"(For extensions) Creates a new SBMLNamespaces object corresponding to\n"
		"the combination of (1) the given SBML 'level' and 'version', and (2)\n"
		"the given 'package' with the 'package' 'version'.\n"
		"\n"
		"SBMLNamespaces objects are used in libSBML to communicate SBML Level\n"
		"and Version data between constructors and other methods.  The\n"
		"SBMLNamespaces object class holds triples consisting of SBML Level,\n"
		"Version, and the corresponding SBML XML namespace.  Most constructors\n"
		"for SBML objects in libSBML take a SBMLNamespaces object as an\n"
		"argument, thereby allowing the constructor to produce the proper\n"
		"combination of attributes and other internal data structures for the\n"
		"given SBML Level and Version.\n"
		"\n"
		"The plural name (SBMLNamespaces) is not a mistake, because in SBML\n"
		"Level 3, objects may have extensions added by Level 3 packages used by\n"
		"a given model and therefore may have multiple namespaces associated\n"
		"with them.  In SBML Levels below Level 3, the SBMLNamespaces object\n"
		"only records one SBML Level/Version/namespace combination at a time.\n"
		"Most constructors for SBML objects in libSBML take a SBMLNamespaces\n"
		"object as an argument, thereby allowing the constructor to produce the\n"
		"proper combination of attributes and other internal data structures\n"
		"for the given SBML Level and Version.\n"
		"\n"
		"Parameter 'level' is the SBML Level. Parameter 'version' is the SBML\n"
		"Version. Parameter 'pkgName' is the string of package name (e.g.\n"
		"'layout', 'multi'). Parameter 'pkgVersion' is the package version.\n"
		"Parameter 'pkgPrefix' is the prefix of the package namespace (e.g.\n"
		"'layout', 'multi') to be added. The package's name will be used if the\n"
		"given string is empty (default).\n"
		"\n"
		"Throws SBMLExtensionException: if the extension module that supports\n"
		"the combination of the given SBML Level, SBML Version, package name,\n"
		"and package version has not been registered with libSBML.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLNamespaces(long level = SBML_DEFAULT_LEVEL, long version\n"
		"= SBML_DEFAULT_VERSION)\n"
		"\n"
		"Creates a new SBMLNamespaces object corresponding to the given SBML\n"
		"'level' and 'version'.\n"
		"\n"
		"SBMLNamespaces objects are used in libSBML to communicate SBML Level\n"
		"and Version data between constructors and other methods.  The\n"
		"SBMLNamespaces object class holds triples consisting of SBML Level,\n"
		"Version, and the corresponding SBML XML namespace.  Most constructors\n"
		"for SBML objects in libSBML take a SBMLNamespaces object as an\n"
		"argument, thereby allowing the constructor to produce the proper\n"
		"combination of attributes and other internal data structures for the\n"
		"given SBML Level and Version.\n"
		"\n"
		"The plural name (SBMLNamespaces) is not a mistake, because in SBML\n"
		"Level 3, objects may have extensions added by Level 3 packages used by\n"
		"a given model and therefore may have multiple namespaces associated\n"
		"with them.  In SBML Levels below Level 3, the SBMLNamespaces object\n"
		"only records one SBML Level/Version/namespace combination at a time.\n"
		"Most constructors for SBML objects in libSBML take a SBMLNamespaces\n"
		"object as an argument, thereby allowing the constructor to produce the\n"
		"proper combination of attributes and other internal data structures\n"
		"for the given SBML Level and Version.\n"
		"\n"
		"Parameter 'level' is the SBML level. Parameter 'version' is the SBML\n"
		"version.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SBMLNamespaces_clone", _wrap_SBMLNamespaces_clone, METH_O, "\n"
		"SBMLNamespaces_clone(SBMLNamespaces self) -> SBMLNamespaces\n"
		"\n"
		"Creates and returns a deep copy of this SBMLNamespaces object.\n"
		"\n"
		"Returns the (deep) copy of this SBMLNamespaces object.\n"
		"\n"
		""},
	 { "SBMLNamespaces_getSBMLNamespaceURI", _wrap_SBMLNamespaces_getSBMLNamespaceURI, METH_VARARGS, "\n"
		"SBMLNamespaces_getSBMLNamespaceURI(unsigned int level, unsigned int version) -> string\n"
		"\n"
		"Returns a string representing the SBML XML namespace for the  given\n"
		"'level' and 'version' of SBML.\n"
		"\n"
		"Parameter 'level' is the SBML level. Parameter 'version' is the SBML\n"
		"version.\n"
		"\n"
		"Returns a string representing the SBML namespace that reflects the\n"
		"SBML Level and Version specified.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBMLNamespaces_getSupportedNamespaces", _wrap_SBMLNamespaces_getSupportedNamespaces, METH_NOARGS, "\n"
		"SBMLNamespaces_getSupportedNamespaces() -> List const *\n"
		"\n"
		"Returns a list of all supported SBMLNamespaces in this version of\n"
		"libsbml.\n"
		"\n"
		"Returns a list with supported SBML namespaces.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBMLNamespaces_freeSBMLNamespaces", _wrap_SBMLNamespaces_freeSBMLNamespaces, METH_O, "\n"
		"SBMLNamespaces_freeSBMLNamespaces(List * supportedNS)\n"
		"\n"
		"Frees the list of supported namespaces as generated by\n"
		"getSupportedNamespaces().\n"
		"\n"
		"Parameter 'supportedNS' is the list to be freed.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBMLNamespaces_getURI", _wrap_SBMLNamespaces_getURI, METH_O, "\n"
		"SBMLNamespaces_getURI(SBMLNamespaces self) -> string\n"
		"\n"
		"Returns a string representing the SBML XML namespace of this object.\n"
		"\n"
		"Returns a string representing the SBML namespace that reflects the\n"
		"SBML Level and Version of this object.\n"
		"\n"
		""},
	 { "SBMLNamespaces_getLevel", _wrap_SBMLNamespaces_getLevel, METH_VARARGS, "\n"
		"SBMLNamespaces_getLevel(SBMLNamespaces self) -> unsigned int\n"
		"SBMLNamespaces_getLevel(SBMLNamespaces self) -> unsigned int\n"
		"\n"
		"Get the SBML Level of this SBMLNamespaces object.\n"
		"\n"
		"Returns the SBML Level of this SBMLNamespaces object.\n"
		"\n"
		""},
	 { "SBMLNamespaces_getVersion", _wrap_SBMLNamespaces_getVersion, METH_VARARGS, "\n"
		"SBMLNamespaces_getVersion(SBMLNamespaces self) -> unsigned int\n"
		"SBMLNamespaces_getVersion(SBMLNamespaces self) -> unsigned int\n"
		"\n"
		"Get the SBML Version of this SBMLNamespaces object.\n"
		"\n"
		"Returns the SBML Version of this SBMLNamespaces object.\n"
		"\n"
		""},
	 { "SBMLNamespaces_getNamespaces", _wrap_SBMLNamespaces_getNamespaces, METH_VARARGS, "\n"
		"SBMLNamespaces_getNamespaces(SBMLNamespaces self) -> XMLNamespaces\n"
		"SBMLNamespaces_getNamespaces(SBMLNamespaces self) -> XMLNamespaces\n"
		"\n"
		"Get the XML namespaces list for this SBMLNamespaces object.\n"
		"\n"
		"SBMLNamespaces objects are used in libSBML to communicate SBML Level\n"
		"and Version data between constructors and other methods.  The\n"
		"SBMLNamespaces object class holds triples consisting of SBML Level,\n"
		"Version, and the corresponding SBML XML namespace.  Most constructors\n"
		"for SBML objects in libSBML take a SBMLNamespaces object as an\n"
		"argument, thereby allowing the constructor to produce the proper\n"
		"combination of attributes and other internal data structures for the\n"
		"given SBML Level and Version.\n"
		"\n"
		"The plural name (SBMLNamespaces) is not a mistake, because in SBML\n"
		"Level 3, objects may have extensions added by Level 3 packages used by\n"
		"a given model and therefore may have multiple namespaces associated\n"
		"with them.  In SBML Levels below Level 3, the SBMLNamespaces object\n"
		"only records one SBML Level/Version/namespace combination at a time.\n"
		"Most constructors for SBML objects in libSBML take a SBMLNamespaces\n"
		"object as an argument, thereby allowing the constructor to produce the\n"
		"proper combination of attributes and other internal data structures\n"
		"for the given SBML Level and Version.\n"
		"\n"
		"Returns the XML namespaces of this SBMLNamespaces object.\n"
		"\n"
		""},
	 { "SBMLNamespaces_addNamespaces", _wrap_SBMLNamespaces_addNamespaces, METH_VARARGS, "\n"
		"SBMLNamespaces_addNamespaces(SBMLNamespaces self, XMLNamespaces xmlns) -> int\n"
		"\n"
		"Add the given XML namespaces list to the set of namespaces within this\n"
		"SBMLNamespaces object.\n"
		"\n"
		"The following code gives an example of how one could add the XHTML\n"
		"namespace to the list of namespaces recorded by the top-level <sbml>\n"
		"element of a model.  It gives the new namespace a prefix of html.\n"
		"\n"
		"  sbmlDoc = None\n"
		"  try:\n"
		"    sbmlDoc = SBMLDocument(3, 1)\n"
		"  except ValueError:\n"
		"    # Do something to handle exceptional situation.  Candidate\n"
		"    # causes include invalid combinations of SBML Level and Version\n"
		"    # (impossible if hardwired as given here), running out of memory, and\n"
		"    # unknown system exceptions.\n"
		"\n"
		"  namespaces = sbmlDoc.getNamespaces()\n"
		"  if namespaces == None:\n"
		"    # Do something to handle case of no namespaces.\n"
		"\n"
		"  status = namespaces.add('http://www.w3.org/1999/xhtml', 'html')\n"
		"  if status != LIBSBML_OPERATION_SUCCESS:\n"
		"    # Do something to handle failure.\n"
		"\n"
		"Parameter 'xmlns' is the XML namespaces to be added.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "SBMLNamespaces_addNamespace", _wrap_SBMLNamespaces_addNamespace, METH_VARARGS, "\n"
		"SBMLNamespaces_addNamespace(SBMLNamespaces self, string uri, string prefix) -> int\n"
		"\n"
		"Add an XML namespace (a pair of URI and prefix) to the set of\n"
		"namespaces within this SBMLNamespaces object.\n"
		"\n"
		"Parameter 'uri' is the XML namespace to be added. Parameter 'prefix'\n"
		"is the prefix of the namespace to be added.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "SBMLNamespaces_removeNamespace", _wrap_SBMLNamespaces_removeNamespace, METH_VARARGS, "\n"
		"SBMLNamespaces_removeNamespace(SBMLNamespaces self, string uri) -> int\n"
		"\n"
		"Removes an XML namespace from the set of namespaces within this\n"
		"SBMLNamespaces object.\n"
		"\n"
		"Parameter 'uri' is the XML namespace to be added.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		""},
	 { "SBMLNamespaces_addPackageNamespace", _wrap_SBMLNamespaces_addPackageNamespace, METH_VARARGS, "\n"
		"SBMLNamespaces_addPackageNamespace(SBMLNamespaces self, string pkgName, unsigned int pkgVersion, string prefix=\"\") -> int\n"
		"\n"
		"Add an XML namespace (a pair of URI and prefix) of a package extension\n"
		"to the set of namespaces within this SBMLNamespaces object.\n"
		"\n"
		"The SBML Level and SBML Version of this object is used.\n"
		"\n"
		"Parameter 'pkgName' is the string of package name (e.g. 'layout',\n"
		"'multi'). Parameter 'pkgVersion' is the package version. Parameter\n"
		"'prefix' is the prefix of the package namespace to be added. The\n"
		"package's name will be used if the given string is empty (default).\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: An XML namespace of a non-registered package extension can't be\n"
		"added by this function (LIBSBML_INVALID_ATTRIBUTE_VALUE  will be\n"
		"returned).\n"
		"\n"
		"See also addNamespace().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "SBMLNamespaces_addPackageNamespaces", _wrap_SBMLNamespaces_addPackageNamespaces, METH_VARARGS, "\n"
		"SBMLNamespaces_addPackageNamespaces(SBMLNamespaces self, XMLNamespaces xmlns) -> int\n"
		"\n"
		"Add the XML namespaces of package extensions in the given XMLNamespace\n"
		"object to the set of namespaces within this SBMLNamespaces object\n"
		"(Non-package XML namespaces are not added by this function).\n"
		"\n"
		"Parameter 'xmlns' is the XML namespaces to be added.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: XML namespaces of a non-registered package extensions are not\n"
		"added (just ignored) by this function. LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"will be returned if the given xmlns is 'None.'\n"
		"\n"
		""},
	 { "SBMLNamespaces_removePackageNamespace", _wrap_SBMLNamespaces_removePackageNamespace, METH_VARARGS, "\n"
		"SBMLNamespaces_removePackageNamespace(SBMLNamespaces self, unsigned int level, unsigned int version, string pkgName, unsigned int pkgVersion) -> int\n"
		"\n"
		"Removes an XML namespace of a package extension from the set of\n"
		"namespaces  within this SBMLNamespaces object.\n"
		"\n"
		"Parameter 'level' is the SBML level. Parameter 'version' is the SBML\n"
		"version. Parameter 'pkgName' is the string of package name (e.g.\n"
		"'layout', 'multi'). Parameter 'pkgVersion' is the package version.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		""},
	 { "SBMLNamespaces_addPkgNamespace", _wrap_SBMLNamespaces_addPkgNamespace, METH_VARARGS, "\n"
		"SBMLNamespaces_addPkgNamespace(SBMLNamespaces self, string pkgName, unsigned int pkgVersion, string prefix=\"\") -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLNamespaces_addPkgNamespaces", _wrap_SBMLNamespaces_addPkgNamespaces, METH_VARARGS, "\n"
		"SBMLNamespaces_addPkgNamespaces(SBMLNamespaces self, XMLNamespaces xmlns) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLNamespaces_removePkgNamespace", _wrap_SBMLNamespaces_removePkgNamespace, METH_VARARGS, "\n"
		"SBMLNamespaces_removePkgNamespace(SBMLNamespaces self, unsigned int level, unsigned int version, string pkgName, unsigned int pkgVersion) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLNamespaces_isSBMLNamespace", _wrap_SBMLNamespaces_isSBMLNamespace, METH_O, "\n"
		"SBMLNamespaces_isSBMLNamespace(string uri) -> bool\n"
		"\n"
		"Predicate returning 'True' if the given URL is one of SBML XML\n"
		"namespaces.\n"
		"\n"
		"Parameter 'uri' is the URI of namespace.\n"
		"\n"
		"Returns 'True' if the 'uri' is one of SBML namespaces, 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "SBMLNamespaces_isValidCombination", _wrap_SBMLNamespaces_isValidCombination, METH_O, "\n"
		"SBMLNamespaces_isValidCombination(SBMLNamespaces self) -> bool\n"
		"\n"
		"Predicate returning 'True' if the given set of namespaces represent a\n"
		"valid set\n"
		"\n"
		"Returns 'True' if the set of namespaces is valid, 'False' otherwise.\n"
		"\n"
		""},
	 { "SBMLNamespaces_setLevel", _wrap_SBMLNamespaces_setLevel, METH_VARARGS, "\n"
		"SBMLNamespaces_setLevel(SBMLNamespaces self, unsigned int level)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLNamespaces_setVersion", _wrap_SBMLNamespaces_setVersion, METH_VARARGS, "\n"
		"SBMLNamespaces_setVersion(SBMLNamespaces self, unsigned int version)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLNamespaces_setNamespaces", _wrap_SBMLNamespaces_setNamespaces, METH_VARARGS, "\n"
		"SBMLNamespaces_setNamespaces(SBMLNamespaces self, XMLNamespaces xmlns)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLNamespaces_getPackageName", _wrap_SBMLNamespaces_getPackageName, METH_O, "\n"
		"SBMLNamespaces_getPackageName(SBMLNamespaces self) -> string\n"
		"\n"
		"Returns the name of the main package for this namespace.\n"
		"\n"
		"Returns the name of the main package for this namespace. 'core' will\n"
		"be returned if this namespace is defined in the SBML  core.\n"
		"\n"
		""},
	 { "SBMLNamespaces_swigregister", SBMLNamespaces_swigregister, METH_O, NULL},
	 { "SBMLNamespaces_swiginit", SBMLNamespaces_swiginit, METH_VARARGS, NULL},
	 { "SBMLTransforms_replaceFD", _wrap_SBMLTransforms_replaceFD, METH_VARARGS, "\n"
		"SBMLTransforms_replaceFD(ASTNode math, FunctionDefinition fd, IdList idsToExclude=None)\n"
		"SBMLTransforms_replaceFD(ASTNode math, ListOfFunctionDefinitions lofd, IdList idsToExclude=None)\n"
		""},
	 { "SBMLTransforms_expandInitialAssignments", _wrap_SBMLTransforms_expandInitialAssignments, METH_O, "\n"
		"SBMLTransforms_expandInitialAssignments(Model m) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLTransforms_evaluateASTNode", _wrap_SBMLTransforms_evaluateASTNode, METH_VARARGS, "\n"
		"SBMLTransforms_evaluateASTNode(ASTNode node, Model m=None) -> double\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLTransforms_expandL3V2InitialAssignments", _wrap_SBMLTransforms_expandL3V2InitialAssignments, METH_O, "\n"
		"SBMLTransforms_expandL3V2InitialAssignments(Model m) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLTransforms_mapComponentValues", _wrap_SBMLTransforms_mapComponentValues, METH_O, "SBMLTransforms_mapComponentValues(Model m) -> IdList"},
	 { "SBMLTransforms_clearComponentValues", _wrap_SBMLTransforms_clearComponentValues, METH_NOARGS, "SBMLTransforms_clearComponentValues()"},
	 { "SBMLTransforms_nodeContainsId", _wrap_SBMLTransforms_nodeContainsId, METH_VARARGS, "SBMLTransforms_nodeContainsId(ASTNode node, IdList ids) -> bool"},
	 { "new_SBMLTransforms", _wrap_new_SBMLTransforms, METH_NOARGS, "\n"
		"new_SBMLTransforms() -> SBMLTransforms\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "delete_SBMLTransforms", _wrap_delete_SBMLTransforms, METH_O, "delete_SBMLTransforms(SBMLTransforms self)"},
	 { "SBMLTransforms_swigregister", SBMLTransforms_swigregister, METH_O, NULL},
	 { "SBMLTransforms_swiginit", SBMLTransforms_swiginit, METH_VARARGS, NULL},
	 { "new_ConversionOption", _wrap_new_ConversionOption, METH_VARARGS, "\n"
		"ConversionOption(string key, string value=\"\", ConversionOptionType_t type=CNV_TYPE_STRING, string description=\"\")\n"
		"ConversionOption(string key, char const * value, string description=\"\")\n"
		"ConversionOption(string key, bool value, string description=\"\")\n"
		"ConversionOption(string key, double value, string description=\"\")\n"
		"ConversionOption(string key, float value, string description=\"\")\n"
		"ConversionOption(string key, int value, string description=\"\")\n"
		"new_ConversionOption(ConversionOption orig) -> ConversionOption\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ConversionOption(string key, bool value, string\n"
		"description='')\n"
		"\n"
		"Creates a new ConversionOption specialized for Boolean-type options.\n"
		"\n"
		"Parameter 'key' is the key for this option. Parameter 'value' is the\n"
		"value for this option. Parameter 'description' is an optional\n"
		"description.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ConversionOption(string key, string value='',\n"
		"ConversionOptionType_t type=CNV_TYPE_STRING, string description='')\n"
		"\n"
		"Creates a new ConversionOption.\n"
		"\n"
		"This is the general constructor, taking arguments for all aspects of\n"
		"an option.  Other constructors exist with different arguments.\n"
		"\n"
		"The conversion 'type' argument value must be one of the constants\n"
		"whose names begin with the characters CNV_TYPE_ in the interface class\n"
		"libsbml.\n"
		"\n"
		"Parameter 'key' is the key for this option. Parameter 'value' is an\n"
		"optional value for this option. Parameter 'type' is the type of this\n"
		"option. Parameter 'description' is the description for this option.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ConversionOption(string key, string value, string\n"
		"description='')\n"
		"\n"
		"Creates a new ConversionOption specialized for string-type options.\n"
		"\n"
		"Parameter 'key' is the key for this option. Parameter 'value' is the\n"
		"value for this option. Parameter 'description' is an optional\n"
		"description.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ConversionOption(string key, double value, string\n"
		"description='')\n"
		"\n"
		"Creates a new ConversionOption specialized for double-type options.\n"
		"\n"
		"Parameter 'key' is the key for this option. Parameter 'value' is the\n"
		"value for this option. Parameter 'description' is an optional\n"
		"description.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ConversionOption(string key, float value, string\n"
		"description='')\n"
		"\n"
		"Creates a new ConversionOption specialized for float-type options.\n"
		"\n"
		"Parameter 'key' is the key for this option. Parameter 'value' is the\n"
		"value for this option. Parameter 'description' is an optional\n"
		"description.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ConversionOption(string key, int value, string\n"
		"description='')\n"
		"\n"
		"Creates a new ConversionOption specialized for integer-type options.\n"
		"\n"
		"Parameter 'key' is the key for this option. Parameter 'value' is the\n"
		"value for this option. Parameter 'description' is an optional\n"
		"description.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ConversionOption(ConversionOption orig)\n"
		"\n"
		"Copy constructor; creates a copy of an ConversionOption object.\n"
		"\n"
		"Parameter 'orig' is the ConversionOption object to copy.\n"
		"\n"
		""},
	 { "delete_ConversionOption", _wrap_delete_ConversionOption, METH_O, "delete_ConversionOption(ConversionOption self)"},
	 { "ConversionOption_clone", _wrap_ConversionOption_clone, METH_O, "\n"
		"ConversionOption_clone(ConversionOption self) -> ConversionOption\n"
		"\n"
		"Creates and returns a deep copy of this ConversionOption object.\n"
		"\n"
		"Returns the (deep) copy of this ConversionOption object.\n"
		"\n"
		""},
	 { "ConversionOption_getKey", _wrap_ConversionOption_getKey, METH_O, "\n"
		"ConversionOption_getKey(ConversionOption self) -> string\n"
		"\n"
		"Returns the key for this option.\n"
		"\n"
		"Returns the key, as a string.\n"
		"\n"
		""},
	 { "ConversionOption_setKey", _wrap_ConversionOption_setKey, METH_VARARGS, "\n"
		"ConversionOption_setKey(ConversionOption self, string key)\n"
		"\n"
		"Sets the key for this option.\n"
		"\n"
		"Parameter 'key' is a string representing the key to set.\n"
		"\n"
		""},
	 { "ConversionOption_getValue", _wrap_ConversionOption_getValue, METH_O, "\n"
		"ConversionOption_getValue(ConversionOption self) -> string\n"
		"\n"
		"Returns the value of this option.\n"
		"\n"
		"Returns the value of this option, as a string.\n"
		"\n"
		""},
	 { "ConversionOption_setValue", _wrap_ConversionOption_setValue, METH_VARARGS, "\n"
		"ConversionOption_setValue(ConversionOption self, string value)\n"
		"\n"
		"Sets the value for this option.\n"
		"\n"
		"Parameter 'value' is the value to set, as a string.\n"
		"\n"
		""},
	 { "ConversionOption_getDescription", _wrap_ConversionOption_getDescription, METH_O, "\n"
		"ConversionOption_getDescription(ConversionOption self) -> string\n"
		"\n"
		"Returns the description string for this option.\n"
		"\n"
		"Returns the description of this option.\n"
		"\n"
		""},
	 { "ConversionOption_setDescription", _wrap_ConversionOption_setDescription, METH_VARARGS, "\n"
		"ConversionOption_setDescription(ConversionOption self, string description)\n"
		"\n"
		"Sets the description text for this option.\n"
		"\n"
		"Parameter 'description' is the description to set for this option.\n"
		"\n"
		""},
	 { "ConversionOption_getType", _wrap_ConversionOption_getType, METH_O, "\n"
		"ConversionOption_getType(ConversionOption self) -> ConversionOptionType_t\n"
		"\n"
		"Returns the type of this option\n"
		"\n"
		"Returns the type of this option.\n"
		"\n"
		""},
	 { "ConversionOption_setType", _wrap_ConversionOption_setType, METH_VARARGS, "\n"
		"ConversionOption_setType(ConversionOption self, ConversionOptionType_t type)\n"
		"\n"
		"Sets the type of this option.\n"
		"\n"
		"The conversion 'type' argument value must be one of the constants\n"
		"whose names begin with the characters CNV_TYPE_ in the interface class\n"
		"libsbml.\n"
		"\n"
		"Parameter 'type' is the type value to use.\n"
		"\n"
		""},
	 { "ConversionOption_getBoolValue", _wrap_ConversionOption_getBoolValue, METH_O, "\n"
		"ConversionOption_getBoolValue(ConversionOption self) -> bool\n"
		"\n"
		"Returns the value of this option as a Boolean.\n"
		"\n"
		"Returns the value of this option.\n"
		"\n"
		""},
	 { "ConversionOption_setBoolValue", _wrap_ConversionOption_setBoolValue, METH_VARARGS, "\n"
		"ConversionOption_setBoolValue(ConversionOption self, bool value)\n"
		"\n"
		"Set the value of this option to a given Boolean value.\n"
		"\n"
		"Invoking this method will also set the type of the option to\n"
		"CNV_TYPE_BOOL.\n"
		"\n"
		"Parameter 'value' is the Boolean value to set.\n"
		"\n"
		""},
	 { "ConversionOption_getDoubleValue", _wrap_ConversionOption_getDoubleValue, METH_O, "\n"
		"ConversionOption_getDoubleValue(ConversionOption self) -> double\n"
		"\n"
		"Returns the value of this option as a 'float.'\n"
		"\n"
		"Returns the value of this option.\n"
		"\n"
		""},
	 { "ConversionOption_setDoubleValue", _wrap_ConversionOption_setDoubleValue, METH_VARARGS, "\n"
		"ConversionOption_setDoubleValue(ConversionOption self, double value)\n"
		"\n"
		"Set the value of this option to a given 'float' value.\n"
		"\n"
		"Invoking this method will also set the type of the option to\n"
		"CNV_TYPE_DOUBLE.\n"
		"\n"
		"Parameter 'value' is the value to set.\n"
		"\n"
		""},
	 { "ConversionOption_getFloatValue", _wrap_ConversionOption_getFloatValue, METH_O, "\n"
		"ConversionOption_getFloatValue(ConversionOption self) -> float\n"
		"\n"
		"Returns the value of this option as a 'float.'\n"
		"\n"
		"Returns the value of this option as a float.\n"
		"\n"
		""},
	 { "ConversionOption_setFloatValue", _wrap_ConversionOption_setFloatValue, METH_VARARGS, "\n"
		"ConversionOption_setFloatValue(ConversionOption self, float value)\n"
		"\n"
		"Set the value of this option to a given 'float' value.\n"
		"\n"
		"Invoking this method will also set the type of the option to\n"
		"CNV_TYPE_SINGLE.\n"
		"\n"
		"Parameter 'value' is the value to set.\n"
		"\n"
		""},
	 { "ConversionOption_getIntValue", _wrap_ConversionOption_getIntValue, METH_O, "\n"
		"ConversionOption_getIntValue(ConversionOption self) -> int\n"
		"\n"
		"Returns the value of this option as an 'integer.'\n"
		"\n"
		"Returns the value of this option, as an int.\n"
		"\n"
		""},
	 { "ConversionOption_setIntValue", _wrap_ConversionOption_setIntValue, METH_VARARGS, "\n"
		"ConversionOption_setIntValue(ConversionOption self, int value)\n"
		"\n"
		"Set the value of this option to a given 'int' value.\n"
		"\n"
		"Invoking this method will also set the type of the option to\n"
		"CNV_TYPE_INT.\n"
		"\n"
		"Parameter 'value' is the value to set.\n"
		"\n"
		""},
	 { "ConversionOption_swigregister", ConversionOption_swigregister, METH_O, NULL},
	 { "ConversionOption_swiginit", ConversionOption_swiginit, METH_VARARGS, NULL},
	 { "new_ConversionProperties", _wrap_new_ConversionProperties, METH_VARARGS, "\n"
		"ConversionProperties(SBMLNamespaces targetNS=None)\n"
		"new_ConversionProperties(ConversionProperties orig) -> ConversionProperties\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ConversionProperties(ConversionProperties orig)\n"
		"\n"
		"Copy constructor.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ConversionProperties(SBMLNamespaces targetNS=None)\n"
		"\n"
		"Constructor that initializes the conversion properties with a specific\n"
		"SBML target namespace.\n"
		"\n"
		"Parameter 'targetNS' is the target namespace to convert to.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		""},
	 { "ConversionProperties_clone", _wrap_ConversionProperties_clone, METH_O, "\n"
		"ConversionProperties_clone(ConversionProperties self) -> ConversionProperties\n"
		"\n"
		"Creates and returns a deep copy of this ConversionProperties object.\n"
		"\n"
		"Returns the (deep) copy of this ConversionProperties object.\n"
		"\n"
		""},
	 { "delete_ConversionProperties", _wrap_delete_ConversionProperties, METH_O, "delete_ConversionProperties(ConversionProperties self)"},
	 { "ConversionProperties_getTargetNamespaces", _wrap_ConversionProperties_getTargetNamespaces, METH_O, "\n"
		"ConversionProperties_getTargetNamespaces(ConversionProperties self) -> SBMLNamespaces\n"
		"\n"
		"Returns the current target SBML namespace.\n"
		"\n"
		"Returns the SBMLNamepaces object expressing the target namespace.\n"
		"\n"
		""},
	 { "ConversionProperties_hasTargetNamespaces", _wrap_ConversionProperties_hasTargetNamespaces, METH_O, "\n"
		"ConversionProperties_hasTargetNamespaces(ConversionProperties self) -> bool\n"
		"\n"
		"Returns 'True' if the target SBML namespace has been set.\n"
		"\n"
		"Returns 'True' if the target namespace has been set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ConversionProperties_setTargetNamespaces", _wrap_ConversionProperties_setTargetNamespaces, METH_VARARGS, "\n"
		"ConversionProperties_setTargetNamespaces(ConversionProperties self, SBMLNamespaces targetNS)\n"
		"\n"
		"Sets the target namespace.\n"
		"\n"
		"Parameter 'targetNS' is the target namespace to use.\n"
		"\n"
		""},
	 { "ConversionProperties_getDescription", _wrap_ConversionProperties_getDescription, METH_VARARGS, "\n"
		"ConversionProperties_getDescription(ConversionProperties self, string key) -> string\n"
		"\n"
		"Returns the description string for a given option in this properties\n"
		"object.\n"
		"\n"
		"Parameter 'key' is the key for the option.\n"
		"\n"
		"Returns the description text of the option with the given key.\n"
		"\n"
		""},
	 { "ConversionProperties_getType", _wrap_ConversionProperties_getType, METH_VARARGS, "\n"
		"ConversionProperties_getType(ConversionProperties self, string key) -> ConversionOptionType_t\n"
		"\n"
		"Returns the type of a given option in this properties object.\n"
		"\n"
		"Parameter 'key' is the key for the option.\n"
		"\n"
		"Returns the type of the option with the given key.\n"
		"\n"
		""},
	 { "ConversionProperties_getOption", _wrap_ConversionProperties_getOption, METH_VARARGS, "\n"
		"ConversionProperties_getOption(ConversionProperties self, string key) -> ConversionOption\n"
		"ConversionProperties_getOption(ConversionProperties self, int index) -> ConversionOption\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getOption(int index)\n"
		"\n"
		"Returns the ConversionOption object for the given 'index'.\n"
		"\n"
		"Parameter 'index' is the index for the option.\n"
		"\n"
		"Returns the option with the given 'index'.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getOption(string key)\n"
		"\n"
		"Returns the ConversionOption object for a given key.\n"
		"\n"
		"Parameter 'key' is the key for the option.\n"
		"\n"
		"Returns the option with the given key.\n"
		"\n"
		""},
	 { "ConversionProperties_addOption", _wrap_ConversionProperties_addOption, METH_VARARGS, "\n"
		"ConversionProperties_addOption(ConversionProperties self, ConversionOption option)\n"
		"ConversionProperties_addOption(ConversionProperties self, string key, string value=\"\", ConversionOptionType_t type=CNV_TYPE_STRING, string description=\"\")\n"
		"ConversionProperties_addOption(ConversionProperties self, string key, char const * value, string description=\"\")\n"
		"ConversionProperties_addOption(ConversionProperties self, string key, bool value, string description=\"\")\n"
		"ConversionProperties_addOption(ConversionProperties self, string key, double value, string description=\"\")\n"
		"ConversionProperties_addOption(ConversionProperties self, string key, float value, string description=\"\")\n"
		"ConversionProperties_addOption(ConversionProperties self, string key, int value, string description=\"\")\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addOption(ConversionOption option)\n"
		"\n"
		"Adds a copy of the given option to this properties object.\n"
		"\n"
		"Parameter 'option' is the option to add.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addOption(string key, double value, string description='')\n"
		"\n"
		"Adds a new ConversionOption object with the given parameters.\n"
		"\n"
		"Parameter 'key' is the key for the new option. Parameter 'value' is\n"
		"the double value of that option. Parameter 'description' is (optional)\n"
		"the description for the option.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addOption(string key, string value='', ConversionOptionType_t\n"
		"type=CNV_TYPE_STRING, string description='')\n"
		"\n"
		"Adds a new ConversionOption object with the given parameters.\n"
		"\n"
		"Parameter 'key' is the key for the new option. Parameter 'value' is\n"
		"(optional) the value of that option. Parameter 'type' is (optional)\n"
		"the type of the option (see the documentation for ConversionOption for\n"
		"more information about the types). Parameter 'description' is\n"
		"(optional) the description for the option.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addOption(string key, string value, string description='')\n"
		"\n"
		"Adds a new ConversionOption object with the given parameters.\n"
		"\n"
		"Parameter 'key' is the key for the new option. Parameter 'value' is\n"
		"the string value of that option. Parameter 'description' is (optional)\n"
		"the description for the option.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addOption(string key, bool value, string description='')\n"
		"\n"
		"Adds a new ConversionOption object with the given parameters.\n"
		"\n"
		"Parameter 'key' is the key for the new option. Parameter 'value' is\n"
		"the boolean value of that option. Parameter 'description' is\n"
		"(optional) the description for the option.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addOption(string key, float value, string description='')\n"
		"\n"
		"Adds a new ConversionOption object with the given parameters.\n"
		"\n"
		"Parameter 'key' is the key for the new option. Parameter 'value' is\n"
		"the float value of that option. Parameter 'description' is (optional)\n"
		"the description for the option.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addOption(string key, int value, string description='')\n"
		"\n"
		"Adds a new ConversionOption object with the given parameters.\n"
		"\n"
		"Parameter 'key' is the key for the new option. Parameter 'value' is\n"
		"the integer value of that option. Parameter 'description' is\n"
		"(optional) the description for the option.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		""},
	 { "ConversionProperties_removeOption", _wrap_ConversionProperties_removeOption, METH_VARARGS, "\n"
		"ConversionProperties_removeOption(ConversionProperties self, string key) -> ConversionOption\n"
		"\n"
		"Removes the option with the given key from this properties object.\n"
		"\n"
		"Parameter 'key' is the key for the new option to remove. Returns the\n"
		"removed option.\n"
		"\n"
		""},
	 { "ConversionProperties_hasOption", _wrap_ConversionProperties_hasOption, METH_VARARGS, "\n"
		"ConversionProperties_hasOption(ConversionProperties self, string key) -> bool\n"
		"\n"
		"Returns 'True' if this properties object contains an option with the\n"
		"given key.\n"
		"\n"
		"Parameter 'key' is the key of the option to find.\n"
		"\n"
		"Returns 'True' if an option with the given 'key' exists in this\n"
		"properties object, 'False' otherwise.\n"
		"\n"
		""},
	 { "ConversionProperties_getValue", _wrap_ConversionProperties_getValue, METH_VARARGS, "\n"
		"ConversionProperties_getValue(ConversionProperties self, string key) -> string\n"
		"\n"
		"Returns the value of the given option as a string.\n"
		"\n"
		"Parameter 'key' is the key for the option.\n"
		"\n"
		"Returns the string value of the option with the given key.\n"
		"\n"
		""},
	 { "ConversionProperties_setValue", _wrap_ConversionProperties_setValue, METH_VARARGS, "\n"
		"ConversionProperties_setValue(ConversionProperties self, string key, string value)\n"
		"\n"
		"Sets the value of the given option to a string.\n"
		"\n"
		"Parameter 'key' is the key for the option. Parameter 'value' is the\n"
		"new value.\n"
		"\n"
		""},
	 { "ConversionProperties_getBoolValue", _wrap_ConversionProperties_getBoolValue, METH_VARARGS, "\n"
		"ConversionProperties_getBoolValue(ConversionProperties self, string key) -> bool\n"
		"\n"
		"Returns the value of the given option as a Boolean.\n"
		"\n"
		"Parameter 'key' is the key for the option.\n"
		"\n"
		"Returns the boolean value of the option with the given key.\n"
		"\n"
		""},
	 { "ConversionProperties_setBoolValue", _wrap_ConversionProperties_setBoolValue, METH_VARARGS, "\n"
		"ConversionProperties_setBoolValue(ConversionProperties self, string key, bool value)\n"
		"\n"
		"Sets the value of the given option to a Boolean.\n"
		"\n"
		"Parameter 'key' is the key for the option.\n"
		"\n"
		"Parameter 'value' is the new Boolean value.\n"
		"\n"
		""},
	 { "ConversionProperties_getDoubleValue", _wrap_ConversionProperties_getDoubleValue, METH_VARARGS, "\n"
		"ConversionProperties_getDoubleValue(ConversionProperties self, string key) -> double\n"
		"\n"
		"Returns the value of the given option as a 'float.'\n"
		"\n"
		"Parameter 'key' is the key for the option.\n"
		"\n"
		"Returns the double value of the option with the given key.\n"
		"\n"
		""},
	 { "ConversionProperties_setDoubleValue", _wrap_ConversionProperties_setDoubleValue, METH_VARARGS, "\n"
		"ConversionProperties_setDoubleValue(ConversionProperties self, string key, double value)\n"
		"\n"
		"Sets the value of the given option to a 'float.'\n"
		"\n"
		"Parameter 'key' is the key for the option.\n"
		"\n"
		"Parameter 'value' is the new double value.\n"
		"\n"
		""},
	 { "ConversionProperties_getFloatValue", _wrap_ConversionProperties_getFloatValue, METH_VARARGS, "\n"
		"ConversionProperties_getFloatValue(ConversionProperties self, string key) -> float\n"
		"\n"
		"Returns the value of the given option as a 'float.'\n"
		"\n"
		"Parameter 'key' is the key for the option.\n"
		"\n"
		"Returns the float value of the option with the given key.\n"
		"\n"
		""},
	 { "ConversionProperties_setFloatValue", _wrap_ConversionProperties_setFloatValue, METH_VARARGS, "\n"
		"ConversionProperties_setFloatValue(ConversionProperties self, string key, float value)\n"
		"\n"
		"Sets the value of the given option to a 'float.'\n"
		"\n"
		"Parameter 'key' is the key for the option.\n"
		"\n"
		"Parameter 'value' is the new float value.\n"
		"\n"
		""},
	 { "ConversionProperties_getIntValue", _wrap_ConversionProperties_getIntValue, METH_VARARGS, "\n"
		"ConversionProperties_getIntValue(ConversionProperties self, string key) -> int\n"
		"\n"
		"Returns the value of the given option as an integer.\n"
		"\n"
		"Parameter 'key' is the key for the option.\n"
		"\n"
		"Returns the int value of the option with the given key.\n"
		"\n"
		""},
	 { "ConversionProperties_setIntValue", _wrap_ConversionProperties_setIntValue, METH_VARARGS, "\n"
		"ConversionProperties_setIntValue(ConversionProperties self, string key, int value)\n"
		"\n"
		"Sets the value of the given option to an integer.\n"
		"\n"
		"Parameter 'key' is the key for the option.\n"
		"\n"
		"Parameter 'value' is the new integer value.\n"
		"\n"
		""},
	 { "ConversionProperties_getNumOptions", _wrap_ConversionProperties_getNumOptions, METH_O, "\n"
		"ConversionProperties_getNumOptions(ConversionProperties self) -> int\n"
		"\n"
		"Returns the number of options in this Conversion Properties object\n"
		"\n"
		"Returns the number of options in this properties object.\n"
		"\n"
		""},
	 { "ConversionProperties_swigregister", ConversionProperties_swigregister, METH_O, NULL},
	 { "ConversionProperties_swiginit", ConversionProperties_swiginit, METH_VARARGS, NULL},
	 { "new_SBMLConverter", _wrap_new_SBMLConverter, METH_VARARGS, "\n"
		"SBMLConverter()\n"
		"SBMLConverter(string name)\n"
		"new_SBMLConverter(PyObject * _self, SBMLConverter orig) -> SBMLConverter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLConverter()\n"
		"\n"
		"Creates a new SBMLConverter object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLConverter(SBMLConverter orig)\n"
		"\n"
		"Copy constructor.\n"
		"\n"
		"This creates a copy of an SBMLConverter object.\n"
		"\n"
		"Parameter 'orig' is the SBMLConverter object to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLConverter(string name)\n"
		"\n"
		"Creates a new SBMLConverter object with a given name.\n"
		"\n"
		"Parameter 'name' is the name for the converter to create.\n"
		"\n"
		""},
	 { "delete_SBMLConverter", _wrap_delete_SBMLConverter, METH_O, "delete_SBMLConverter(SBMLConverter self)"},
	 { "SBMLConverter_clone", _wrap_SBMLConverter_clone, METH_O, "\n"
		"SBMLConverter_clone(SBMLConverter self) -> SBMLConverter\n"
		"\n"
		"Creates and returns a deep copy of this SBMLConverter object.\n"
		"\n"
		"Returns the (deep) copy of this SBMLConverter object.\n"
		"\n"
		""},
	 { "SBMLConverter_getDocument", _wrap_SBMLConverter_getDocument, METH_VARARGS, "\n"
		"SBMLConverter_getDocument(SBMLConverter self) -> SBMLDocument\n"
		"SBMLConverter_getDocument(SBMLConverter self) -> SBMLDocument\n"
		"\n"
		"Returns the SBML document that is the subject of the conversions.\n"
		"\n"
		"Returns the current SBMLDocument object.\n"
		"\n"
		""},
	 { "SBMLConverter_getDefaultProperties", _wrap_SBMLConverter_getDefaultProperties, METH_O, "\n"
		"SBMLConverter_getDefaultProperties(SBMLConverter self) -> ConversionProperties\n"
		"\n"
		"Returns the default properties of this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the default property settings for this converter.  It is meant\n"
		"to be called in order to discover all the settings for the converter\n"
		"object.  The run-time properties of the converter object can be\n"
		"adjusted by using the method SBMLConverter.setProperties().\n"
		"\n"
		"Returns the default properties for the converter.\n"
		"\n"
		"See also setProperties(), matchesProperties().\n"
		"\n"
		""},
	 { "SBMLConverter_getTargetNamespaces", _wrap_SBMLConverter_getTargetNamespaces, METH_O, "\n"
		"SBMLConverter_getTargetNamespaces(SBMLConverter self) -> SBMLNamespaces\n"
		"\n"
		"Returns the target SBML namespaces of the currently set properties.\n"
		"\n"
		"SBML namespaces are used by libSBML to express the Level+Version of\n"
		"the SBML document (and, possibly, any SBML Level 3 packages in use).\n"
		"Some converters' behavior is affected by the SBML namespace configured\n"
		"in the converter.  For example, in SBMLLevelVersionConverter (the\n"
		"converter for converting SBML documents from one Level+Version\n"
		"combination to another), the actions are fundamentally dependent on\n"
		"the SBML namespaces targeted.\n"
		"\n"
		"Returns the SBMLNamespaces object that describes the SBML namespaces\n"
		"in effect, or 'None' if none are set.\n"
		"\n"
		""},
	 { "SBMLConverter_matchesProperties", _wrap_SBMLConverter_matchesProperties, METH_VARARGS, "\n"
		"SBMLConverter_matchesProperties(SBMLConverter self, ConversionProperties props) -> bool\n"
		"\n"
		"Returns 'True' if this converter matches the given properties.\n"
		"\n"
		"Given a ConversionProperties object 'props', this method checks that\n"
		"'props' possesses an option value to enable this converter.  If it\n"
		"does, this method returns 'True.'\n"
		"\n"
		"Parameter 'props' is the properties to match.\n"
		"\n"
		"Returns 'True' if the properties 'props' would match the necessary\n"
		"properties for this type of converter, 'False' otherwise.\n"
		"\n"
		""},
	 { "SBMLConverter_setDocument", _wrap_SBMLConverter_setDocument, METH_VARARGS, "\n"
		"SBMLConverter_setDocument(SBMLConverter self, SBMLDocument doc) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setDocument(SBMLDocument doc)\n"
		"\n"
		"Sets the SBML document to be converted.\n"
		"\n"
		"Parameter 'doc' is the document to use for this conversion.\n"
		"\n"
		"Returns integer value indicating the success/failure of the operation.\n"
		"The set of possible values that may be returned ultimately depends on\n"
		"the specific subclass of SBMLConverter being used, but the default\n"
		"method can return the following:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setDocument(SBMLDocument doc)\n"
		"\n"
		"Sets the SBML document to be converted.\n"
		"\n"
		"Parameter 'doc' is the document to use for this conversion.\n"
		"\n"
		"Returns integer value indicating the success/failure of the operation.\n"
		"The set of possible values that may be returned ultimately depends on\n"
		"the specific subclass of SBMLConverter being used, but the default\n"
		"method can return the following:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "SBMLConverter_setProperties", _wrap_SBMLConverter_setProperties, METH_VARARGS, "\n"
		"SBMLConverter_setProperties(SBMLConverter self, ConversionProperties props) -> int\n"
		"\n"
		"Sets the configuration properties to be used by this converter.\n"
		"\n"
		"Parameter 'props' is the ConversionProperties object defining the\n"
		"properties to set.\n"
		"\n"
		"Returns integer value indicating the success/failure of the operation.\n"
		"The set of possible values that may be returned ultimately depends on\n"
		"the specific subclass of SBMLConverter being used, but the default\n"
		"method can return the following values:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getProperties(), matchesProperties().\n"
		"\n"
		""},
	 { "SBMLConverter_getProperties", _wrap_SBMLConverter_getProperties, METH_O, "\n"
		"SBMLConverter_getProperties(SBMLConverter self) -> ConversionProperties\n"
		"\n"
		"Returns the current properties in effect for this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the current properties for this converter; in other words, the\n"
		"settings in effect at this moment.  To change the property values, you\n"
		"can use SBMLConverter.setProperties().\n"
		"\n"
		"Returns the currently set configuration properties.\n"
		"\n"
		"See also setProperties(), matchesProperties().\n"
		"\n"
		""},
	 { "SBMLConverter_convert", _wrap_SBMLConverter_convert, METH_O, "\n"
		"SBMLConverter_convert(SBMLConverter self) -> int\n"
		"\n"
		"Perform the conversion.\n"
		"\n"
		"This method causes the converter to do the actual conversion work,\n"
		"that is, to convert the SBMLDocument object set by\n"
		"SBMLConverter.setDocument() and with the configuration options set by\n"
		"SBMLConverter.setProperties().\n"
		"\n"
		"Returns integer value indicating the success/failure of the operation.\n"
		"The set of possible values that may be returned depends on the\n"
		"converter subclass; please consult the documentation for the relevant\n"
		"class to find out what the possibilities are.\n"
		"\n"
		""},
	 { "SBMLConverter_getName", _wrap_SBMLConverter_getName, METH_O, "\n"
		"SBMLConverter_getName(SBMLConverter self) -> string\n"
		"\n"
		"Returns the name of this converter.\n"
		"\n"
		"Returns a string, the name of this converter.\n"
		"\n"
		""},
	 { "disown_SBMLConverter", _wrap_disown_SBMLConverter, METH_O, NULL},
	 { "SBMLConverter_swigregister", SBMLConverter_swigregister, METH_O, NULL},
	 { "SBMLConverter_swiginit", SBMLConverter_swiginit, METH_VARARGS, NULL},
	 { "SBMLConverterRegistry_getInstance", _wrap_SBMLConverterRegistry_getInstance, METH_NOARGS, "\n"
		"SBMLConverterRegistry_getInstance() -> SBMLConverterRegistry\n"
		"\n"
		"Returns the singleton instance for the converter registry.\n"
		"\n"
		"Prior to using the registry, callers have to obtain a copy of the\n"
		"registry.  This static method provides the means for doing that.\n"
		"\n"
		"Returns the singleton for the converter registry.\n"
		"\n"
		""},
	 { "SBMLConverterRegistry_addConverter", _wrap_SBMLConverterRegistry_addConverter, METH_VARARGS, "\n"
		"SBMLConverterRegistry_addConverter(SBMLConverterRegistry self, SBMLConverter converter) -> int\n"
		"\n"
		"Adds the given converter to the registry of SBML converters.\n"
		"\n"
		"Parameter 'converter' is the converter to add to the registry.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "SBMLConverterRegistry_getConverterByIndex", _wrap_SBMLConverterRegistry_getConverterByIndex, METH_VARARGS, "\n"
		"SBMLConverterRegistry_getConverterByIndex(SBMLConverterRegistry self, int index) -> SBMLConverter\n"
		"\n"
		"Returns the converter with the given index number.\n"
		"\n"
		"Converters are given arbitrary index numbers by the registry.  Callers\n"
		"can use the method SBMLConverterRegistry.getNumConverters() to find\n"
		"out how many converters are registered, then use this method to\n"
		"iterate over the list and obtain each one in turn.\n"
		"\n"
		"Parameter 'index' is the zero-based index of the converter to fetch.\n"
		"\n"
		"Returns the converter with the given index number, or 'None' if the\n"
		"number is less than '0' or there is no converter at the given index\n"
		"position.\n"
		"\n"
		""},
	 { "SBMLConverterRegistry_getConverterFor", _wrap_SBMLConverterRegistry_getConverterFor, METH_VARARGS, "\n"
		"SBMLConverterRegistry_getConverterFor(SBMLConverterRegistry self, ConversionProperties props) -> SBMLConverter\n"
		"\n"
		"Returns the converter that best matches the given configuration\n"
		"properties.\n"
		"\n"
		"Many converters provide the ability to configure their behavior.  This\n"
		"is realized through the use of properties that offer different\n"
		"options.  The present method allows callers to search for converters\n"
		"that have specific property values.  Callers can do this by creating a\n"
		"ConversionProperties object, adding the desired option(s) to the\n"
		"object, then passing the object to this method.\n"
		"\n"
		"Parameter 'props' is a ConversionProperties object defining the\n"
		"properties to match against.\n"
		"\n"
		"Returns the converter matching the properties, or 'None' if no\n"
		"suitable converter is found.\n"
		"\n"
		"See also getConverterByIndex().\n"
		"\n"
		""},
	 { "SBMLConverterRegistry_getNumConverters", _wrap_SBMLConverterRegistry_getNumConverters, METH_O, "\n"
		"SBMLConverterRegistry_getNumConverters(SBMLConverterRegistry self) -> int\n"
		"\n"
		"Returns the number of converters known by the registry.\n"
		"\n"
		"Returns the number of registered converters.\n"
		"\n"
		"See also getConverterByIndex().\n"
		"\n"
		""},
	 { "delete_SBMLConverterRegistry", _wrap_delete_SBMLConverterRegistry, METH_O, "delete_SBMLConverterRegistry(SBMLConverterRegistry self)"},
	 { "SBMLConverterRegistry_swigregister", SBMLConverterRegistry_swigregister, METH_O, NULL},
	 { "SBMLFunctionDefinitionConverter_init", _wrap_SBMLFunctionDefinitionConverter_init, METH_NOARGS, "\n"
		"SBMLFunctionDefinitionConverter_init()\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SBMLFunctionDefinitionConverter", _wrap_new_SBMLFunctionDefinitionConverter, METH_VARARGS, "\n"
		"SBMLFunctionDefinitionConverter()\n"
		"new_SBMLFunctionDefinitionConverter(SBMLFunctionDefinitionConverter obj) -> SBMLFunctionDefinitionConverter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLFunctionDefinitionConverter()\n"
		"\n"
		"Creates a new SBMLFunctionDefinitionConverter object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLFunctionDefinitionConverter(SBMLFunctionDefinitionConvert\n"
		"er obj)\n"
		"\n"
		"Copy constructor; creates a copy of an SBMLFunctionDefinitionConverter\n"
		"object.\n"
		"\n"
		"Parameter 'obj' is the SBMLFunctionDefinitionConverter object to copy.\n"
		"\n"
		""},
	 { "SBMLFunctionDefinitionConverter_clone", _wrap_SBMLFunctionDefinitionConverter_clone, METH_O, "\n"
		"SBMLFunctionDefinitionConverter_clone(SBMLFunctionDefinitionConverter self) -> SBMLFunctionDefinitionConverter\n"
		"\n"
		"Creates and returns a deep copy of this\n"
		"SBMLFunctionDefinitionConverter object.\n"
		"\n"
		"Returns a (deep) copy of this converter.\n"
		"\n"
		""},
	 { "delete_SBMLFunctionDefinitionConverter", _wrap_delete_SBMLFunctionDefinitionConverter, METH_O, "delete_SBMLFunctionDefinitionConverter(SBMLFunctionDefinitionConverter self)"},
	 { "SBMLFunctionDefinitionConverter_matchesProperties", _wrap_SBMLFunctionDefinitionConverter_matchesProperties, METH_VARARGS, "\n"
		"SBMLFunctionDefinitionConverter_matchesProperties(SBMLFunctionDefinitionConverter self, ConversionProperties props) -> bool\n"
		"\n"
		"Returns 'True' if this converter object's properties match the given\n"
		"properties.\n"
		"\n"
		"A typical use of this method involves creating a ConversionProperties\n"
		"object, setting the options desired, and then calling this method on\n"
		"an SBMLFunctionDefinitionConverter object to find out if the object's\n"
		"property values match the given ones.  This method is also used by\n"
		"SBMLConverterRegistry.getConverterFor() to search across all\n"
		"registered converters for one matching particular properties.\n"
		"\n"
		"Parameter 'props' is the properties to match.\n"
		"\n"
		"Returns 'True' if this converter's properties match, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLFunctionDefinitionConverter_convert", _wrap_SBMLFunctionDefinitionConverter_convert, METH_O, "\n"
		"SBMLFunctionDefinitionConverter_convert(SBMLFunctionDefinitionConverter self) -> int\n"
		"\n"
		"Perform the conversion.\n"
		"\n"
		"This method causes the converter to do the actual conversion work,\n"
		"that is, to convert the SBMLDocument object set by\n"
		"SBMLConverter.setDocument() and with the configuration options set by\n"
		"SBMLConverter.setProperties().\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_CONV_INVALID_SRC_DOCUMENT\n"
		"\n"
		""},
	 { "SBMLFunctionDefinitionConverter_getDefaultProperties", _wrap_SBMLFunctionDefinitionConverter_getDefaultProperties, METH_O, "\n"
		"SBMLFunctionDefinitionConverter_getDefaultProperties(SBMLFunctionDefinitionConverter self) -> ConversionProperties\n"
		"\n"
		"Returns the default properties of this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the default property settings for this converter.  It is meant\n"
		"to be called in order to discover all the settings for the converter\n"
		"object.\n"
		"\n"
		"Returns the ConversionProperties object describing the default\n"
		"properties for this converter.\n"
		"\n"
		""},
	 { "SBMLFunctionDefinitionConverter_swigregister", SBMLFunctionDefinitionConverter_swigregister, METH_O, NULL},
	 { "SBMLFunctionDefinitionConverter_swiginit", SBMLFunctionDefinitionConverter_swiginit, METH_VARARGS, NULL},
	 { "SBMLIdConverter_init", _wrap_SBMLIdConverter_init, METH_NOARGS, "\n"
		"SBMLIdConverter_init()\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SBMLIdConverter", _wrap_new_SBMLIdConverter, METH_VARARGS, "\n"
		"SBMLIdConverter()\n"
		"new_SBMLIdConverter(SBMLIdConverter obj) -> SBMLIdConverter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLIdConverter(SBMLIdConverter obj)\n"
		"\n"
		"Copy constructor; creates a copy of an SBMLIdConverter object.\n"
		"\n"
		"Parameter 'obj' is the SBMLIdConverter object to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLIdConverter()\n"
		"\n"
		"Creates a new SBMLIdConverter object.\n"
		"\n"
		""},
	 { "SBMLIdConverter_clone", _wrap_SBMLIdConverter_clone, METH_O, "\n"
		"SBMLIdConverter_clone(SBMLIdConverter self) -> SBMLIdConverter\n"
		"\n"
		"Creates and returns a deep copy of this SBMLIdConverter object.\n"
		"\n"
		"Returns a (deep) copy of this converter.\n"
		"\n"
		""},
	 { "delete_SBMLIdConverter", _wrap_delete_SBMLIdConverter, METH_O, "delete_SBMLIdConverter(SBMLIdConverter self)"},
	 { "SBMLIdConverter_matchesProperties", _wrap_SBMLIdConverter_matchesProperties, METH_VARARGS, "\n"
		"SBMLIdConverter_matchesProperties(SBMLIdConverter self, ConversionProperties props) -> bool\n"
		"\n"
		"Returns 'True' if this converter object's properties match the given\n"
		"properties.\n"
		"\n"
		"A typical use of this method involves creating a ConversionProperties\n"
		"object, setting the options desired, and then calling this method on\n"
		"an SBMLIdConverter object to find out if the object's property values\n"
		"match the given ones.  This method is also used by\n"
		"SBMLConverterRegistry.getConverterFor() to search across all\n"
		"registered converters for one matching particular properties.\n"
		"\n"
		"Parameter 'props' is the properties to match.\n"
		"\n"
		"Returns 'True' if this converter's properties match, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLIdConverter_convert", _wrap_SBMLIdConverter_convert, METH_O, "\n"
		"SBMLIdConverter_convert(SBMLIdConverter self) -> int\n"
		"\n"
		"Perform the conversion.\n"
		"\n"
		"This method causes the converter to do the actual conversion work,\n"
		"that is, to convert the SBMLDocument object set by\n"
		"SBMLConverter.setDocument() and with the configuration options set by\n"
		"SBMLConverter.setProperties().\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "SBMLIdConverter_getDefaultProperties", _wrap_SBMLIdConverter_getDefaultProperties, METH_O, "\n"
		"SBMLIdConverter_getDefaultProperties(SBMLIdConverter self) -> ConversionProperties\n"
		"\n"
		"Returns the default properties of this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the default property settings for this converter.  It is meant\n"
		"to be called in order to discover all the settings for the converter\n"
		"object.\n"
		"\n"
		"Returns the ConversionProperties object describing the default\n"
		"properties for this converter.\n"
		"\n"
		""},
	 { "SBMLIdConverter_swigregister", SBMLIdConverter_swigregister, METH_O, NULL},
	 { "SBMLIdConverter_swiginit", SBMLIdConverter_swiginit, METH_VARARGS, NULL},
	 { "SBMLInferUnitsConverter_init", _wrap_SBMLInferUnitsConverter_init, METH_NOARGS, "\n"
		"SBMLInferUnitsConverter_init()\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SBMLInferUnitsConverter", _wrap_new_SBMLInferUnitsConverter, METH_VARARGS, "\n"
		"SBMLInferUnitsConverter()\n"
		"new_SBMLInferUnitsConverter(SBMLInferUnitsConverter obj) -> SBMLInferUnitsConverter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLInferUnitsConverter()\n"
		"\n"
		"Creates a new SBMLInferUnitsConverter object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLInferUnitsConverter(SBMLInferUnitsConverter obj)\n"
		"\n"
		"Copy constructor; creates a copy of an SBMLInferUnitsConverter object.\n"
		"\n"
		"Parameter 'obj' is the SBMLInferUnitsConverter object to copy.\n"
		"\n"
		""},
	 { "delete_SBMLInferUnitsConverter", _wrap_delete_SBMLInferUnitsConverter, METH_O, "delete_SBMLInferUnitsConverter(SBMLInferUnitsConverter self)"},
	 { "SBMLInferUnitsConverter_clone", _wrap_SBMLInferUnitsConverter_clone, METH_O, "\n"
		"SBMLInferUnitsConverter_clone(SBMLInferUnitsConverter self) -> SBMLInferUnitsConverter\n"
		"\n"
		"Creates and returns a deep copy of this SBMLInferUnitsConverter\n"
		"object.\n"
		"\n"
		"Returns a (deep) copy of this converter.\n"
		"\n"
		""},
	 { "SBMLInferUnitsConverter_matchesProperties", _wrap_SBMLInferUnitsConverter_matchesProperties, METH_VARARGS, "\n"
		"SBMLInferUnitsConverter_matchesProperties(SBMLInferUnitsConverter self, ConversionProperties props) -> bool\n"
		"\n"
		"Returns 'True' if this converter object's properties match the given\n"
		"properties.\n"
		"\n"
		"A typical use of this method involves creating a ConversionProperties\n"
		"object, setting the options desired, and then calling this method on\n"
		"an SBMLInferUnitsConverter object to find out if the object's property\n"
		"values match the given ones.  This method is also used by\n"
		"SBMLConverterRegistry.getConverterFor() to search across all\n"
		"registered converters for one matching particular properties.\n"
		"\n"
		"Parameter 'props' is the properties to match.\n"
		"\n"
		"Returns 'True' if this converter's properties match, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLInferUnitsConverter_convert", _wrap_SBMLInferUnitsConverter_convert, METH_O, "\n"
		"SBMLInferUnitsConverter_convert(SBMLInferUnitsConverter self) -> int\n"
		"\n"
		"Perform the conversion.\n"
		"\n"
		"This method causes the converter to do the actual conversion work,\n"
		"that is, to convert the SBMLDocument object set by\n"
		"SBMLConverter.setDocument() and with the configuration options set by\n"
		"SBMLConverter.setProperties().\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_CONV_INVALID_SRC_DOCUMENT\n"
		"\n"
		""},
	 { "SBMLInferUnitsConverter_getDefaultProperties", _wrap_SBMLInferUnitsConverter_getDefaultProperties, METH_O, "\n"
		"SBMLInferUnitsConverter_getDefaultProperties(SBMLInferUnitsConverter self) -> ConversionProperties\n"
		"\n"
		"Returns the default properties of this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the default property settings for this converter.  It is meant\n"
		"to be called in order to discover all the settings for the converter\n"
		"object.\n"
		"\n"
		"Returns the ConversionProperties object describing the default\n"
		"properties for this converter.\n"
		"\n"
		""},
	 { "SBMLInferUnitsConverter_swigregister", SBMLInferUnitsConverter_swigregister, METH_O, NULL},
	 { "SBMLInferUnitsConverter_swiginit", SBMLInferUnitsConverter_swiginit, METH_VARARGS, NULL},
	 { "SBMLInitialAssignmentConverter_init", _wrap_SBMLInitialAssignmentConverter_init, METH_NOARGS, "\n"
		"SBMLInitialAssignmentConverter_init()\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SBMLInitialAssignmentConverter", _wrap_new_SBMLInitialAssignmentConverter, METH_VARARGS, "\n"
		"SBMLInitialAssignmentConverter()\n"
		"new_SBMLInitialAssignmentConverter(SBMLInitialAssignmentConverter obj) -> SBMLInitialAssignmentConverter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLInitialAssignmentConverter(SBMLInitialAssignmentConverter\n"
		"obj)\n"
		"\n"
		"Copy constructor; creates a copy of an SBMLInitialAssignmentConverter\n"
		"object.\n"
		"\n"
		"Parameter 'obj' is the SBMLInitialAssignmentConverter object to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLInitialAssignmentConverter()\n"
		"\n"
		"Creates a new SBMLInitialAssignmentConverter object.\n"
		"\n"
		""},
	 { "SBMLInitialAssignmentConverter_clone", _wrap_SBMLInitialAssignmentConverter_clone, METH_O, "\n"
		"SBMLInitialAssignmentConverter_clone(SBMLInitialAssignmentConverter self) -> SBMLInitialAssignmentConverter\n"
		"\n"
		"Creates and returns a deep copy of this SBMLInitialAssignmentConverter\n"
		"object.\n"
		"\n"
		"Returns a (deep) copy of this converter.\n"
		"\n"
		""},
	 { "delete_SBMLInitialAssignmentConverter", _wrap_delete_SBMLInitialAssignmentConverter, METH_O, "delete_SBMLInitialAssignmentConverter(SBMLInitialAssignmentConverter self)"},
	 { "SBMLInitialAssignmentConverter_matchesProperties", _wrap_SBMLInitialAssignmentConverter_matchesProperties, METH_VARARGS, "\n"
		"SBMLInitialAssignmentConverter_matchesProperties(SBMLInitialAssignmentConverter self, ConversionProperties props) -> bool\n"
		"\n"
		"Returns 'True' if this converter object's properties match the given\n"
		"properties.\n"
		"\n"
		"A typical use of this method involves creating a ConversionProperties\n"
		"object, setting the options desired, and then calling this method on\n"
		"an SBMLInitialAssignmentConverter object to find out if the object's\n"
		"property values match the given ones.  This method is also used by\n"
		"SBMLConverterRegistry.getConverterFor() to search across all\n"
		"registered converters for one matching particular properties.\n"
		"\n"
		"Parameter 'props' is the properties to match.\n"
		"\n"
		"Returns 'True' if this converter's properties match, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLInitialAssignmentConverter_convert", _wrap_SBMLInitialAssignmentConverter_convert, METH_O, "\n"
		"SBMLInitialAssignmentConverter_convert(SBMLInitialAssignmentConverter self) -> int\n"
		"\n"
		"Perform the conversion.\n"
		"\n"
		"This method causes the converter to do the actual conversion work,\n"
		"that is, to convert the SBMLDocument object set by\n"
		"SBMLConverter.setDocument() and with the configuration options set by\n"
		"SBMLConverter.setProperties().\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "SBMLInitialAssignmentConverter_getDefaultProperties", _wrap_SBMLInitialAssignmentConverter_getDefaultProperties, METH_O, "\n"
		"SBMLInitialAssignmentConverter_getDefaultProperties(SBMLInitialAssignmentConverter self) -> ConversionProperties\n"
		"\n"
		"Returns the default properties of this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the default property settings for this converter.  It is meant\n"
		"to be called in order to discover all the settings for the converter\n"
		"object.\n"
		"\n"
		"Returns the ConversionProperties object describing the default\n"
		"properties for this converter.\n"
		"\n"
		""},
	 { "SBMLInitialAssignmentConverter_swigregister", SBMLInitialAssignmentConverter_swigregister, METH_O, NULL},
	 { "SBMLInitialAssignmentConverter_swiginit", SBMLInitialAssignmentConverter_swiginit, METH_VARARGS, NULL},
	 { "SBMLLevelVersionConverter_init", _wrap_SBMLLevelVersionConverter_init, METH_NOARGS, "\n"
		"SBMLLevelVersionConverter_init()\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SBMLLevelVersionConverter", _wrap_new_SBMLLevelVersionConverter, METH_VARARGS, "\n"
		"SBMLLevelVersionConverter()\n"
		"new_SBMLLevelVersionConverter(SBMLLevelVersionConverter obj) -> SBMLLevelVersionConverter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLLevelVersionConverter()\n"
		"\n"
		"Creates a new SBMLLevelVersionConverter object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLLevelVersionConverter(SBMLLevelVersionConverter obj)\n"
		"\n"
		"Copy constructor; creates a copy of an SBMLLevelVersionConverter\n"
		"object.\n"
		"\n"
		"Parameter 'obj' is the SBMLLevelVersionConverter object to copy.\n"
		"\n"
		""},
	 { "delete_SBMLLevelVersionConverter", _wrap_delete_SBMLLevelVersionConverter, METH_O, "delete_SBMLLevelVersionConverter(SBMLLevelVersionConverter self)"},
	 { "SBMLLevelVersionConverter_clone", _wrap_SBMLLevelVersionConverter_clone, METH_O, "\n"
		"SBMLLevelVersionConverter_clone(SBMLLevelVersionConverter self) -> SBMLLevelVersionConverter\n"
		"\n"
		"Creates and returns a deep copy of this SBMLLevelVersionConverter\n"
		"object.\n"
		"\n"
		"Returns a (deep) copy of this converter.\n"
		"\n"
		""},
	 { "SBMLLevelVersionConverter_matchesProperties", _wrap_SBMLLevelVersionConverter_matchesProperties, METH_VARARGS, "\n"
		"SBMLLevelVersionConverter_matchesProperties(SBMLLevelVersionConverter self, ConversionProperties props) -> bool\n"
		"\n"
		"Returns 'True' if this converter object's properties match the given\n"
		"properties.\n"
		"\n"
		"A typical use of this method involves creating a ConversionProperties\n"
		"object, setting the options desired, and then calling this method on\n"
		"an SBMLLevelVersionConverter object to find out if the object's\n"
		"property values match the given ones.  This method is also used by\n"
		"SBMLConverterRegistry.getConverterFor() to search across all\n"
		"registered converters for one matching particular properties.\n"
		"\n"
		"Parameter 'props' is the properties to match.\n"
		"\n"
		"Returns 'True' if this converter's properties match, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLLevelVersionConverter_convert", _wrap_SBMLLevelVersionConverter_convert, METH_O, "\n"
		"SBMLLevelVersionConverter_convert(SBMLLevelVersionConverter self) -> int\n"
		"\n"
		"Perform the conversion.\n"
		"\n"
		"This method causes the converter to do the actual conversion work,\n"
		"that is, to convert the SBMLDocument object set by\n"
		"SBMLConverter.setDocument() and with the configuration options set by\n"
		"SBMLConverter.setProperties().\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_CONV_INVALID_TARGET_NAMESPACE\n"
		"\n"
		"* LIBSBML_CONV_PKG_CONVERSION_NOT_AVAILABLE\n"
		"\n"
		"* LIBSBML_CONV_INVALID_SRC_DOCUMENT\n"
		"\n"
		""},
	 { "SBMLLevelVersionConverter_getDefaultProperties", _wrap_SBMLLevelVersionConverter_getDefaultProperties, METH_O, "\n"
		"SBMLLevelVersionConverter_getDefaultProperties(SBMLLevelVersionConverter self) -> ConversionProperties\n"
		"\n"
		"Returns the default properties of this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the default property settings for this converter.  It is meant\n"
		"to be called in order to discover all the settings for the converter\n"
		"object.\n"
		"\n"
		"Returns the ConversionProperties object describing the default\n"
		"properties for this converter.\n"
		"\n"
		""},
	 { "SBMLLevelVersionConverter_getTargetLevel", _wrap_SBMLLevelVersionConverter_getTargetLevel, METH_O, "\n"
		"SBMLLevelVersionConverter_getTargetLevel(SBMLLevelVersionConverter self) -> unsigned int\n"
		"\n"
		"Returns the target SBML Level for the conversion.\n"
		"\n"
		"Returns an integer indicating the SBML Level.\n"
		"\n"
		""},
	 { "SBMLLevelVersionConverter_getTargetVersion", _wrap_SBMLLevelVersionConverter_getTargetVersion, METH_O, "\n"
		"SBMLLevelVersionConverter_getTargetVersion(SBMLLevelVersionConverter self) -> unsigned int\n"
		"\n"
		"Returns the target SBML Version for the conversion.\n"
		"\n"
		"Returns an integer indicating the Version within the SBML Level.\n"
		"\n"
		""},
	 { "SBMLLevelVersionConverter_getValidityFlag", _wrap_SBMLLevelVersionConverter_getValidityFlag, METH_O, "\n"
		"SBMLLevelVersionConverter_getValidityFlag(SBMLLevelVersionConverter self) -> bool\n"
		"\n"
		"Returns the flag indicating whether the conversion has been set to\n"
		"'strict'.\n"
		"\n"
		"Returns 'True' if strict validity has been requested, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLLevelVersionConverter_getAddDefaultUnits", _wrap_SBMLLevelVersionConverter_getAddDefaultUnits, METH_O, "\n"
		"SBMLLevelVersionConverter_getAddDefaultUnits(SBMLLevelVersionConverter self) -> bool\n"
		"\n"
		"Returns the flag indicating whether default units should be added when\n"
		"converting to L3 or not.\n"
		"\n"
		"Returns 'True' if default units should be added, 'False' otherwise.\n"
		"\n"
		""},
	 { "SBMLLevelVersionConverter_swigregister", SBMLLevelVersionConverter_swigregister, METH_O, NULL},
	 { "SBMLLevelVersionConverter_swiginit", SBMLLevelVersionConverter_swiginit, METH_VARARGS, NULL},
	 { "SBMLLevel1Version1Converter_init", _wrap_SBMLLevel1Version1Converter_init, METH_NOARGS, "\n"
		"SBMLLevel1Version1Converter_init()\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SBMLLevel1Version1Converter", _wrap_new_SBMLLevel1Version1Converter, METH_VARARGS, "\n"
		"SBMLLevel1Version1Converter()\n"
		"new_SBMLLevel1Version1Converter(SBMLLevel1Version1Converter obj) -> SBMLLevel1Version1Converter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLLevel1Version1Converter()\n"
		"\n"
		"Creates a new SBMLLevel1Version1Converter object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLLevel1Version1Converter(SBMLLevel1Version1Converter obj)\n"
		"\n"
		"Copy constructor; creates a copy of an SBMLLevel1Version1Converter\n"
		"object.\n"
		"\n"
		"Parameter 'obj' is the SBMLLevel1Version1Converter object to copy.\n"
		"\n"
		""},
	 { "delete_SBMLLevel1Version1Converter", _wrap_delete_SBMLLevel1Version1Converter, METH_O, "delete_SBMLLevel1Version1Converter(SBMLLevel1Version1Converter self)"},
	 { "SBMLLevel1Version1Converter_clone", _wrap_SBMLLevel1Version1Converter_clone, METH_O, "\n"
		"SBMLLevel1Version1Converter_clone(SBMLLevel1Version1Converter self) -> SBMLLevel1Version1Converter\n"
		"\n"
		"Creates and returns a deep copy of this SBMLLevel1Version1Converter\n"
		"object.\n"
		"\n"
		"Returns a (deep) copy of this converter.\n"
		"\n"
		""},
	 { "SBMLLevel1Version1Converter_matchesProperties", _wrap_SBMLLevel1Version1Converter_matchesProperties, METH_VARARGS, "\n"
		"SBMLLevel1Version1Converter_matchesProperties(SBMLLevel1Version1Converter self, ConversionProperties props) -> bool\n"
		"\n"
		"Returns 'True' if this converter object's properties match the given\n"
		"properties.\n"
		"\n"
		"A typical use of this method involves creating a ConversionProperties\n"
		"object, setting the options desired, and then calling this method on\n"
		"an SBMLLevel1Version1Converter object to find out if the object's\n"
		"property values match the given ones.  This method is also used by\n"
		"SBMLConverterRegistry.getConverterFor() to search across all\n"
		"registered converters for one matching particular properties.\n"
		"\n"
		"Parameter 'props' is the properties to match.\n"
		"\n"
		"Returns 'True' if this converter's properties match, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLLevel1Version1Converter_convert", _wrap_SBMLLevel1Version1Converter_convert, METH_O, "\n"
		"SBMLLevel1Version1Converter_convert(SBMLLevel1Version1Converter self) -> int\n"
		"\n"
		"Perform the conversion.\n"
		"\n"
		"This method causes the converter to do the actual conversion work,\n"
		"that is, to convert the SBMLDocument object set by\n"
		"SBMLConverter.setDocument() and with the configuration options set by\n"
		"SBMLConverter.setProperties().\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_CONV_INVALID_TARGET_NAMESPACE\n"
		"\n"
		"* LIBSBML_CONV_PKG_CONVERSION_NOT_AVAILABLE\n"
		"\n"
		"* LIBSBML_CONV_INVALID_SRC_DOCUMENT\n"
		"\n"
		""},
	 { "SBMLLevel1Version1Converter_getDefaultProperties", _wrap_SBMLLevel1Version1Converter_getDefaultProperties, METH_O, "\n"
		"SBMLLevel1Version1Converter_getDefaultProperties(SBMLLevel1Version1Converter self) -> ConversionProperties\n"
		"\n"
		"Returns the default properties of this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the default property settings for this converter.  It is meant\n"
		"to be called in order to discover all the settings for the converter\n"
		"object.\n"
		"\n"
		"Returns the ConversionProperties object describing the default\n"
		"properties for this converter.\n"
		"\n"
		""},
	 { "SBMLLevel1Version1Converter_swigregister", SBMLLevel1Version1Converter_swigregister, METH_O, NULL},
	 { "SBMLLevel1Version1Converter_swiginit", SBMLLevel1Version1Converter_swiginit, METH_VARARGS, NULL},
	 { "SBMLLocalParameterConverter_init", _wrap_SBMLLocalParameterConverter_init, METH_NOARGS, "\n"
		"SBMLLocalParameterConverter_init()\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SBMLLocalParameterConverter", _wrap_new_SBMLLocalParameterConverter, METH_VARARGS, "\n"
		"SBMLLocalParameterConverter()\n"
		"new_SBMLLocalParameterConverter(SBMLLocalParameterConverter obj) -> SBMLLocalParameterConverter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLLocalParameterConverter(SBMLLocalParameterConverter obj)\n"
		"\n"
		"Copy constructor; creates a copy of an SBMLLocalParameterConverter\n"
		"object.\n"
		"\n"
		"Parameter 'obj' is the SBMLLocalParameterConverter object to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLLocalParameterConverter()\n"
		"\n"
		"Creates a new SBMLLocalParameterConverter object.\n"
		"\n"
		""},
	 { "SBMLLocalParameterConverter_clone", _wrap_SBMLLocalParameterConverter_clone, METH_O, "\n"
		"SBMLLocalParameterConverter_clone(SBMLLocalParameterConverter self) -> SBMLLocalParameterConverter\n"
		"\n"
		"Creates and returns a deep copy of this SBMLLocalParameterConverter\n"
		"object.\n"
		"\n"
		"Returns a (deep) copy of this converter.\n"
		"\n"
		""},
	 { "delete_SBMLLocalParameterConverter", _wrap_delete_SBMLLocalParameterConverter, METH_O, "delete_SBMLLocalParameterConverter(SBMLLocalParameterConverter self)"},
	 { "SBMLLocalParameterConverter_matchesProperties", _wrap_SBMLLocalParameterConverter_matchesProperties, METH_VARARGS, "\n"
		"SBMLLocalParameterConverter_matchesProperties(SBMLLocalParameterConverter self, ConversionProperties props) -> bool\n"
		"\n"
		"Returns 'True' if this converter object's properties match the given\n"
		"properties.\n"
		"\n"
		"A typical use of this method involves creating a ConversionProperties\n"
		"object, setting the options desired, and then calling this method on\n"
		"an SBMLLocalParameterConverter object to find out if the object's\n"
		"property values match the given ones.  This method is also used by\n"
		"SBMLConverterRegistry.getConverterFor() to search across all\n"
		"registered converters for one matching particular properties.\n"
		"\n"
		"Parameter 'props' is the properties to match.\n"
		"\n"
		"Returns 'True' if this converter's properties match, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLLocalParameterConverter_convert", _wrap_SBMLLocalParameterConverter_convert, METH_O, "\n"
		"SBMLLocalParameterConverter_convert(SBMLLocalParameterConverter self) -> int\n"
		"\n"
		"Perform the conversion.\n"
		"\n"
		"This method causes the converter to do the actual conversion work,\n"
		"that is, to convert the SBMLDocument object set by\n"
		"SBMLConverter.setDocument() and with the configuration options set by\n"
		"SBMLConverter.setProperties().\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "SBMLLocalParameterConverter_getDefaultProperties", _wrap_SBMLLocalParameterConverter_getDefaultProperties, METH_O, "\n"
		"SBMLLocalParameterConverter_getDefaultProperties(SBMLLocalParameterConverter self) -> ConversionProperties\n"
		"\n"
		"Returns the default properties of this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the default property settings for this converter.  It is meant\n"
		"to be called in order to discover all the settings for the converter\n"
		"object.\n"
		"\n"
		"Returns the ConversionProperties object describing the default\n"
		"properties for this converter.\n"
		"\n"
		""},
	 { "SBMLLocalParameterConverter_swigregister", SBMLLocalParameterConverter_swigregister, METH_O, NULL},
	 { "SBMLLocalParameterConverter_swiginit", SBMLLocalParameterConverter_swiginit, METH_VARARGS, NULL},
	 { "SBMLReactionConverter_init", _wrap_SBMLReactionConverter_init, METH_NOARGS, "\n"
		"SBMLReactionConverter_init()\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SBMLReactionConverter", _wrap_new_SBMLReactionConverter, METH_VARARGS, "\n"
		"SBMLReactionConverter()\n"
		"new_SBMLReactionConverter(SBMLReactionConverter obj) -> SBMLReactionConverter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLReactionConverter(SBMLReactionConverter obj)\n"
		"\n"
		"Copy constructor; creates a copy of an SBMLReactionConverter object.\n"
		"\n"
		"Parameter 'obj' is the SBMLReactionConverter object to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLReactionConverter()\n"
		"\n"
		"Creates a new SBMLReactionConverter object.\n"
		"\n"
		""},
	 { "SBMLReactionConverter_clone", _wrap_SBMLReactionConverter_clone, METH_O, "\n"
		"SBMLReactionConverter_clone(SBMLReactionConverter self) -> SBMLReactionConverter\n"
		"\n"
		"Creates and returns a deep copy of this SBMLReactionConverter object.\n"
		"\n"
		"Returns a (deep) copy of this converter.\n"
		"\n"
		""},
	 { "delete_SBMLReactionConverter", _wrap_delete_SBMLReactionConverter, METH_O, "delete_SBMLReactionConverter(SBMLReactionConverter self)"},
	 { "SBMLReactionConverter_matchesProperties", _wrap_SBMLReactionConverter_matchesProperties, METH_VARARGS, "\n"
		"SBMLReactionConverter_matchesProperties(SBMLReactionConverter self, ConversionProperties props) -> bool\n"
		"\n"
		"Returns 'True' if this converter object's properties match the given\n"
		"properties.\n"
		"\n"
		"A typical use of this method involves creating a ConversionProperties\n"
		"object, setting the options desired, and then calling this method on\n"
		"an SBMLReactionConverter object to find out if the object's property\n"
		"values match the given ones.  This method is also used by\n"
		"SBMLConverterRegistry.getConverterFor() to search across all\n"
		"registered converters for one matching particular properties.\n"
		"\n"
		"Parameter 'props' is the properties to match.\n"
		"\n"
		"Returns 'True' if this converter's properties match, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLReactionConverter_convert", _wrap_SBMLReactionConverter_convert, METH_O, "\n"
		"SBMLReactionConverter_convert(SBMLReactionConverter self) -> int\n"
		"\n"
		"Perform the conversion.\n"
		"\n"
		"This method causes the converter to do the actual conversion work,\n"
		"that is, to convert the SBMLDocument object set by\n"
		"SBMLConverter.setDocument() and with the configuration options set by\n"
		"SBMLConverter.setProperties().\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_CONV_INVALID_SRC_DOCUMENT\n"
		"\n"
		""},
	 { "SBMLReactionConverter_getDefaultProperties", _wrap_SBMLReactionConverter_getDefaultProperties, METH_O, "\n"
		"SBMLReactionConverter_getDefaultProperties(SBMLReactionConverter self) -> ConversionProperties\n"
		"\n"
		"Returns the default properties of this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the default property settings for this converter.  It is meant\n"
		"to be called in order to discover all the settings for the converter\n"
		"object.\n"
		"\n"
		"Returns the ConversionProperties object describing the default\n"
		"properties for this converter.\n"
		"\n"
		""},
	 { "SBMLReactionConverter_setDocument", _wrap_SBMLReactionConverter_setDocument, METH_VARARGS, "\n"
		"SBMLReactionConverter_setDocument(SBMLReactionConverter self, SBMLDocument doc) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setDocument(SBMLDocument doc)\n"
		"\n"
		"Sets the current SBML document to the given SBMLDocument object.\n"
		"\n"
		"Parameter 'doc' is the document to use for this conversion.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Even though the 'doc' is '', it is immediately cast to a non- version,\n"
		"which is then usually changed by the converter upon a successful\n"
		"conversion.  This function is here solely to preserve backwards\n"
		"compatibility.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setDocument(SBMLDocument doc)\n"
		"\n"
		"Sets the current SBML document to the given SBMLDocument object.\n"
		"\n"
		"Parameter 'doc' is the document to use for this conversion.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "SBMLReactionConverter_swigregister", SBMLReactionConverter_swigregister, METH_O, NULL},
	 { "SBMLReactionConverter_swiginit", SBMLReactionConverter_swiginit, METH_VARARGS, NULL},
	 { "SBMLRuleConverter_init", _wrap_SBMLRuleConverter_init, METH_NOARGS, "\n"
		"SBMLRuleConverter_init()\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SBMLRuleConverter", _wrap_new_SBMLRuleConverter, METH_VARARGS, "\n"
		"SBMLRuleConverter()\n"
		"new_SBMLRuleConverter(SBMLRuleConverter obj) -> SBMLRuleConverter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLRuleConverter(SBMLRuleConverter obj)\n"
		"\n"
		"Copy constructor; creates a copy of an SBMLLevelVersionConverter\n"
		"object.\n"
		"\n"
		"Parameter 'obj' is the SBMLLevelVersionConverter object to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLRuleConverter()\n"
		"\n"
		"Creates a new SBMLLevelVersionConverter object.\n"
		"\n"
		""},
	 { "SBMLRuleConverter_clone", _wrap_SBMLRuleConverter_clone, METH_O, "\n"
		"SBMLRuleConverter_clone(SBMLRuleConverter self) -> SBMLRuleConverter\n"
		"\n"
		"Creates and returns a deep copy of this SBMLLevelVersionConverter\n"
		"object.\n"
		"\n"
		"Returns a (deep) copy of this converter.\n"
		"\n"
		""},
	 { "delete_SBMLRuleConverter", _wrap_delete_SBMLRuleConverter, METH_O, "delete_SBMLRuleConverter(SBMLRuleConverter self)"},
	 { "SBMLRuleConverter_matchesProperties", _wrap_SBMLRuleConverter_matchesProperties, METH_VARARGS, "\n"
		"SBMLRuleConverter_matchesProperties(SBMLRuleConverter self, ConversionProperties props) -> bool\n"
		"\n"
		"Returns 'True' if this converter object's properties match the given\n"
		"properties.\n"
		"\n"
		"A typical use of this method involves creating a ConversionProperties\n"
		"object, setting the options desired, and then calling this method on\n"
		"an SBMLLevelVersionConverter object to find out if the object's\n"
		"property values match the given ones.  This method is also used by\n"
		"SBMLConverterRegistry.getConverterFor() to search across all\n"
		"registered converters for one matching particular properties.\n"
		"\n"
		"Parameter 'props' is the properties to match.\n"
		"\n"
		"Returns 'True' if this converter's properties match, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLRuleConverter_convert", _wrap_SBMLRuleConverter_convert, METH_O, "\n"
		"SBMLRuleConverter_convert(SBMLRuleConverter self) -> int\n"
		"\n"
		"Perform the conversion.\n"
		"\n"
		"This method causes the converter to do the actual conversion work,\n"
		"that is, to convert the SBMLDocument object set by\n"
		"SBMLConverter.setDocument() and with the configuration options set by\n"
		"SBMLConverter.setProperties().\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_CONV_INVALID_SRC_DOCUMENT\n"
		"\n"
		""},
	 { "SBMLRuleConverter_getDefaultProperties", _wrap_SBMLRuleConverter_getDefaultProperties, METH_O, "\n"
		"SBMLRuleConverter_getDefaultProperties(SBMLRuleConverter self) -> ConversionProperties\n"
		"\n"
		"Returns the default properties of this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the default property settings for this converter.  It is meant\n"
		"to be called in order to discover all the settings for the converter\n"
		"object.\n"
		"\n"
		"Returns the ConversionProperties object describing the default\n"
		"properties for this converter.\n"
		"\n"
		""},
	 { "SBMLRuleConverter_swigregister", SBMLRuleConverter_swigregister, METH_O, NULL},
	 { "SBMLRuleConverter_swiginit", SBMLRuleConverter_swiginit, METH_VARARGS, NULL},
	 { "SBMLStripPackageConverter_init", _wrap_SBMLStripPackageConverter_init, METH_NOARGS, "\n"
		"SBMLStripPackageConverter_init()\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SBMLStripPackageConverter", _wrap_new_SBMLStripPackageConverter, METH_VARARGS, "\n"
		"SBMLStripPackageConverter()\n"
		"new_SBMLStripPackageConverter(SBMLStripPackageConverter obj) -> SBMLStripPackageConverter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLStripPackageConverter()\n"
		"\n"
		"Creates a new SBMLStripPackageConverter object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLStripPackageConverter(SBMLStripPackageConverter obj)\n"
		"\n"
		"Copy constructor; creates a copy of an SBMLStripPackageConverter\n"
		"object.\n"
		"\n"
		"Parameter 'obj' is the SBMLStripPackageConverter object to copy.\n"
		"\n"
		""},
	 { "delete_SBMLStripPackageConverter", _wrap_delete_SBMLStripPackageConverter, METH_O, "delete_SBMLStripPackageConverter(SBMLStripPackageConverter self)"},
	 { "SBMLStripPackageConverter_clone", _wrap_SBMLStripPackageConverter_clone, METH_O, "\n"
		"SBMLStripPackageConverter_clone(SBMLStripPackageConverter self) -> SBMLStripPackageConverter\n"
		"\n"
		"Creates and returns a deep copy of this SBMLStripPackageConverter\n"
		"object.\n"
		"\n"
		"Returns the (deep) copy of this converter object.\n"
		"\n"
		""},
	 { "SBMLStripPackageConverter_matchesProperties", _wrap_SBMLStripPackageConverter_matchesProperties, METH_VARARGS, "\n"
		"SBMLStripPackageConverter_matchesProperties(SBMLStripPackageConverter self, ConversionProperties props) -> bool\n"
		"\n"
		"Returns 'True' if this converter object's properties match the given\n"
		"properties.\n"
		"\n"
		"A typical use of this method involves creating a ConversionProperties\n"
		"object, setting the options desired, and then calling this method on\n"
		"an SBMLStripPackageConverter object to find out if the object's\n"
		"property values match the given ones.  This method is also used by\n"
		"SBMLConverterRegistry.getConverterFor() to search across all\n"
		"registered converters for one matching particular properties.\n"
		"\n"
		"Parameter 'props' is the properties to match.\n"
		"\n"
		"Returns 'True' if this converter's properties match, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLStripPackageConverter_convert", _wrap_SBMLStripPackageConverter_convert, METH_O, "\n"
		"SBMLStripPackageConverter_convert(SBMLStripPackageConverter self) -> int\n"
		"\n"
		"Perform the conversion.\n"
		"\n"
		"This method causes the converter to do the actual conversion work,\n"
		"that is, to convert the SBMLDocument object set by\n"
		"SBMLConverter.setDocument() and with the configuration options set by\n"
		"SBMLConverter.setProperties().\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"* LIBSBML_CONV_PKG_CONSIDERED_UNKNOWN\n"
		"\n"
		""},
	 { "SBMLStripPackageConverter_getDefaultProperties", _wrap_SBMLStripPackageConverter_getDefaultProperties, METH_O, "\n"
		"SBMLStripPackageConverter_getDefaultProperties(SBMLStripPackageConverter self) -> ConversionProperties\n"
		"\n"
		"Returns the default properties of this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the default property settings for this converter.  It is meant\n"
		"to be called in order to discover all the settings for the converter\n"
		"object.\n"
		"\n"
		"Returns the ConversionProperties object describing the default\n"
		"properties for this converter.\n"
		"\n"
		""},
	 { "SBMLStripPackageConverter_getPackageToStrip", _wrap_SBMLStripPackageConverter_getPackageToStrip, METH_O, "\n"
		"SBMLStripPackageConverter_getPackageToStrip(SBMLStripPackageConverter self) -> string\n"
		"\n"
		"Returns the package to be stripped.\n"
		"\n"
		""},
	 { "SBMLStripPackageConverter_isStripAllUnrecognizedPackages", _wrap_SBMLStripPackageConverter_isStripAllUnrecognizedPackages, METH_O, "\n"
		"SBMLStripPackageConverter_isStripAllUnrecognizedPackages(SBMLStripPackageConverter self) -> bool\n"
		"\n"
		"Returns a boolean indicating whether all unrecognized packages should\n"
		"be removed.\n"
		"\n"
		""},
	 { "SBMLStripPackageConverter_swigregister", SBMLStripPackageConverter_swigregister, METH_O, NULL},
	 { "SBMLStripPackageConverter_swiginit", SBMLStripPackageConverter_swiginit, METH_VARARGS, NULL},
	 { "SBMLUnitsConverter_init", _wrap_SBMLUnitsConverter_init, METH_NOARGS, "\n"
		"SBMLUnitsConverter_init()\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_SBMLUnitsConverter", _wrap_new_SBMLUnitsConverter, METH_VARARGS, "\n"
		"SBMLUnitsConverter()\n"
		"new_SBMLUnitsConverter(SBMLUnitsConverter obj) -> SBMLUnitsConverter\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLUnitsConverter()\n"
		"\n"
		"Creates a new SBMLUnitsConverter object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLUnitsConverter(SBMLUnitsConverter obj)\n"
		"\n"
		"Copy constructor; creates a copy of an SBMLUnitsConverter object.\n"
		"\n"
		"Parameter 'obj' is the SBMLUnitsConverter object to copy.\n"
		"\n"
		""},
	 { "delete_SBMLUnitsConverter", _wrap_delete_SBMLUnitsConverter, METH_O, "delete_SBMLUnitsConverter(SBMLUnitsConverter self)"},
	 { "SBMLUnitsConverter_clone", _wrap_SBMLUnitsConverter_clone, METH_O, "\n"
		"SBMLUnitsConverter_clone(SBMLUnitsConverter self) -> SBMLUnitsConverter\n"
		"\n"
		"Creates and returns a deep copy of this SBMLUnitsConverter object.\n"
		"\n"
		"Returns a (deep) copy of this converter.\n"
		"\n"
		""},
	 { "SBMLUnitsConverter_matchesProperties", _wrap_SBMLUnitsConverter_matchesProperties, METH_VARARGS, "\n"
		"SBMLUnitsConverter_matchesProperties(SBMLUnitsConverter self, ConversionProperties props) -> bool\n"
		"\n"
		"Returns 'True' if this converter object's properties match the given\n"
		"properties.\n"
		"\n"
		"A typical use of this method involves creating a ConversionProperties\n"
		"object, setting the options desired, and then calling this method on\n"
		"an SBMLUnitsConverter object to find out if the object's property\n"
		"values match the given ones.  This method is also used by\n"
		"SBMLConverterRegistry.getConverterFor() to search across all\n"
		"registered converters for one matching particular properties.\n"
		"\n"
		"Parameter 'props' is the properties to match.\n"
		"\n"
		"Returns 'True' if this converter's properties match, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "SBMLUnitsConverter_convert", _wrap_SBMLUnitsConverter_convert, METH_O, "\n"
		"SBMLUnitsConverter_convert(SBMLUnitsConverter self) -> int\n"
		"\n"
		"Perform the conversion.\n"
		"\n"
		"This method causes the converter to do the actual conversion work,\n"
		"that is, to convert the SBMLDocument object set by\n"
		"SBMLConverter.setDocument() and with the configuration options set by\n"
		"SBMLConverter.setProperties().\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_CONV_CONVERSION_NOT_AVAILABLE\n"
		"\n"
		"* LIBSBML_CONV_INVALID_SRC_DOCUMENT\n"
		"\n"
		""},
	 { "SBMLUnitsConverter_getDefaultProperties", _wrap_SBMLUnitsConverter_getDefaultProperties, METH_O, "\n"
		"SBMLUnitsConverter_getDefaultProperties(SBMLUnitsConverter self) -> ConversionProperties\n"
		"\n"
		"Returns the default properties of this converter.\n"
		"\n"
		"A given converter exposes one or more properties that can be adjusted\n"
		"in order to influence the behavior of the converter.  This method\n"
		"returns the default property settings for this converter.  It is meant\n"
		"to be called in order to discover all the settings for the converter\n"
		"object.\n"
		"\n"
		"Returns the ConversionProperties object describing the default\n"
		"properties for this converter.\n"
		"\n"
		""},
	 { "SBMLUnitsConverter_swigregister", SBMLUnitsConverter_swigregister, METH_O, NULL},
	 { "SBMLUnitsConverter_swiginit", SBMLUnitsConverter_swiginit, METH_VARARGS, NULL},
	 { "new_SBMLValidator", _wrap_new_SBMLValidator, METH_VARARGS, "\n"
		"SBMLValidator()\n"
		"new_SBMLValidator(PyObject * _self, SBMLValidator orig) -> SBMLValidator\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLValidator()\n"
		"\n"
		"Creates a new SBMLValidator.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLValidator(SBMLValidator orig)\n"
		"\n"
		"Copy constructor; creates a copy of an SBMLValidator object.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "delete_SBMLValidator", _wrap_delete_SBMLValidator, METH_O, "delete_SBMLValidator(SBMLValidator self)"},
	 { "SBMLValidator_clone", _wrap_SBMLValidator_clone, METH_O, "\n"
		"SBMLValidator_clone(SBMLValidator self) -> SBMLValidator\n"
		"\n"
		"Creates and returns a deep copy of this SBMLValidator object.\n"
		"\n"
		"Returns the (deep) copy of this SBMLValidator object.\n"
		"\n"
		""},
	 { "SBMLValidator_getDocument", _wrap_SBMLValidator_getDocument, METH_VARARGS, "\n"
		"SBMLValidator_getDocument(SBMLValidator self) -> SBMLDocument\n"
		"SBMLValidator_getDocument(SBMLValidator self) -> SBMLDocument\n"
		"\n"
		"Returns the current SBML document in use by this validator.\n"
		"\n"
		"Returns the current SBML document.\n"
		"\n"
		"See also setDocument().\n"
		"\n"
		""},
	 { "SBMLValidator_setDocument", _wrap_SBMLValidator_setDocument, METH_VARARGS, "\n"
		"SBMLValidator_setDocument(SBMLValidator self, SBMLDocument doc) -> int\n"
		"\n"
		"Sets the current SBML document to the given SBMLDocument object.\n"
		"\n"
		"Parameter 'doc' is the document to use for this validation.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also getDocument().\n"
		"\n"
		""},
	 { "SBMLValidator_clearFailures", _wrap_SBMLValidator_clearFailures, METH_O, "\n"
		"SBMLValidator_clearFailures(SBMLValidator self)\n"
		"\n"
		"Clears this validator's list of failures.\n"
		"\n"
		"If you are validating multiple SBML documents with the same validator,\n"
		"call this method after you have processed the list of failures from\n"
		"the last validation run and before validating the next document.\n"
		"\n"
		""},
	 { "SBMLValidator_logFailure", _wrap_SBMLValidator_logFailure, METH_VARARGS, "\n"
		"SBMLValidator_logFailure(SBMLValidator self, SBMLError err)\n"
		"\n"
		"Adds the given failure to this list of Validators failures.\n"
		"\n"
		"Parameter 'err' is an SBMLError object representing an error or\n"
		"warning.\n"
		"\n"
		""},
	 { "SBMLValidator_validate", _wrap_SBMLValidator_validate, METH_VARARGS, "\n"
		"SBMLValidator_validate(SBMLValidator self) -> unsigned int\n"
		"SBMLValidator_validate(SBMLValidator self, SBMLDocument d) -> unsigned int\n"
		"SBMLValidator_validate(SBMLValidator self, string filename) -> unsigned int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    validate(string filename)\n"
		"\n"
		"Validates the SBML document located at the given 'filename'.\n"
		"\n"
		"This is a convenience method that saves callers the trouble of using\n"
		"SBMLReader to read the document first.\n"
		"\n"
		"Parameter 'filename' is the path to the file to be read and validated.\n"
		"\n"
		"Returns the number of validation failures that occurred.  The objects\n"
		"describing the actual failures can be retrieved using getFailures().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    validate()\n"
		"\n"
		"Runs this validator on the current SBML document.\n"
		"\n"
		"Returns an integer value indicating the success/failure of the\n"
		"validation.   The possible values returned by this function are\n"
		"determined by the specific subclasses of this class.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    validate(SBMLDocument d)\n"
		"\n"
		"Validates the given SBMLDocument object.\n"
		"\n"
		"This is identical to calling setDocument() followed by validate().\n"
		"\n"
		"Parameter 'd' is the SBML document to validate.\n"
		"\n"
		"Returns the number of validation failures that occurred.  The objects\n"
		"describing the actual failures can be retrieved using getFailures().\n"
		"\n"
		""},
	 { "SBMLValidator_getErrorLog", _wrap_SBMLValidator_getErrorLog, METH_O, "\n"
		"SBMLValidator_getErrorLog(SBMLValidator self) -> SBMLErrorLog\n"
		"\n"
		"Returns the list of errors or warnings logged during parsing,\n"
		"consistency checking, or attempted translation of this model.\n"
		"\n"
		"Note that this refers to the SBMLDocument object's error log (i.e.,\n"
		"the list returned by SBMLDocument.getErrorLog()).  That list of errors\n"
		"and warnings is separate from the validation failures tracked by this\n"
		"validator (i.e., the list returned by getFailures()).\n"
		"\n"
		"Returns the SBMLErrorLog used for the SBMLDocument.\n"
		"\n"
		""},
	 { "SBMLValidator_getModel", _wrap_SBMLValidator_getModel, METH_VARARGS, "\n"
		"SBMLValidator_getModel(SBMLValidator self) -> Model\n"
		"SBMLValidator_getModel(SBMLValidator self) -> Model\n"
		"\n"
		"Returns the Model object stored in the SBMLDocument.\n"
		"\n"
		"It is important to note that this method does not create a Model\n"
		"instance.  The model in the SBMLDocument must have been created at\n"
		"some prior time, for example using SBMLDocument.createModel()  or\n"
		"SBMLDocument.setModel(). This method returns 'None' if a model does\n"
		"not yet exist.\n"
		"\n"
		"Returns the Model contained in this validator's SBMLDocument object.\n"
		"\n"
		"See also SBMLDocument.setModel(), SBMLDocument.createModel().\n"
		"\n"
		""},
	 { "SBMLValidator_getNumFailures", _wrap_SBMLValidator_getNumFailures, METH_O, "\n"
		"SBMLValidator_getNumFailures(SBMLValidator self) -> unsigned int\n"
		"\n"
		"Returns the number of failures encountered in the last validation run.\n"
		"\n"
		"This method returns the number of failures logged by this validator.\n"
		"This number only reflects this validator's actions; the number may not\n"
		"be the same as the number of errors and warnings logged on the\n"
		"SBMLDocument object's error log (i.e., the object returned by\n"
		"SBMLDocument.getErrorLog()), because other parts of libSBML may log\n"
		"errors and warnings beyond those found by this validator.\n"
		"\n"
		"Returns the number of errors logged by this validator.\n"
		"\n"
		""},
	 { "SBMLValidator_getFailure", _wrap_SBMLValidator_getFailure, METH_VARARGS, "\n"
		"SBMLValidator_getFailure(SBMLValidator self, unsigned int n) -> SBMLError\n"
		"\n"
		"Returns the failure object at index n in this validator's list of\n"
		"failures logged during the last run.\n"
		"\n"
		"Callers should use getNumFailures() first, to find out the number of\n"
		"entries in this validator's list of failures.\n"
		"\n"
		"Parameter 'n' is an integer indicating the index of the object to\n"
		"return from the failures list; index values start at 0.\n"
		"\n"
		"Returns the failure at the given index number.\n"
		"\n"
		"See also getNumFailures().\n"
		"\n"
		""},
	 { "disown_SBMLValidator", _wrap_disown_SBMLValidator, METH_O, NULL},
	 { "SBMLValidator_swigregister", SBMLValidator_swigregister, METH_O, NULL},
	 { "SBMLValidator_swiginit", SBMLValidator_swiginit, METH_VARARGS, NULL},
	 { "new_SBMLExternalValidator", _wrap_new_SBMLExternalValidator, METH_VARARGS, "\n"
		"SBMLExternalValidator()\n"
		"new_SBMLExternalValidator(SBMLExternalValidator orig) -> SBMLExternalValidator\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExternalValidator_clone", _wrap_SBMLExternalValidator_clone, METH_O, "\n"
		"SBMLExternalValidator_clone(SBMLExternalValidator self) -> SBMLValidator\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "delete_SBMLExternalValidator", _wrap_delete_SBMLExternalValidator, METH_O, "delete_SBMLExternalValidator(SBMLExternalValidator self)"},
	 { "SBMLExternalValidator_validate", _wrap_SBMLExternalValidator_validate, METH_O, "\n"
		"SBMLExternalValidator_validate(SBMLExternalValidator self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExternalValidator_getProgram", _wrap_SBMLExternalValidator_getProgram, METH_O, "\n"
		"SBMLExternalValidator_getProgram(SBMLExternalValidator self) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExternalValidator_setProgram", _wrap_SBMLExternalValidator_setProgram, METH_VARARGS, "\n"
		"SBMLExternalValidator_setProgram(SBMLExternalValidator self, string program)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExternalValidator_getOutputFileName", _wrap_SBMLExternalValidator_getOutputFileName, METH_O, "\n"
		"SBMLExternalValidator_getOutputFileName(SBMLExternalValidator self) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExternalValidator_setOutputFileName", _wrap_SBMLExternalValidator_setOutputFileName, METH_VARARGS, "\n"
		"SBMLExternalValidator_setOutputFileName(SBMLExternalValidator self, string outputFileName)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExternalValidator_getSBMLFileName", _wrap_SBMLExternalValidator_getSBMLFileName, METH_O, "\n"
		"SBMLExternalValidator_getSBMLFileName(SBMLExternalValidator self) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExternalValidator_setSBMLFileName", _wrap_SBMLExternalValidator_setSBMLFileName, METH_VARARGS, "\n"
		"SBMLExternalValidator_setSBMLFileName(SBMLExternalValidator self, string sbmlFileName)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExternalValidator_clearArguments", _wrap_SBMLExternalValidator_clearArguments, METH_O, "\n"
		"SBMLExternalValidator_clearArguments(SBMLExternalValidator self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExternalValidator_addArgument", _wrap_SBMLExternalValidator_addArgument, METH_VARARGS, "\n"
		"SBMLExternalValidator_addArgument(SBMLExternalValidator self, string arg)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExternalValidator_getNumArguments", _wrap_SBMLExternalValidator_getNumArguments, METH_O, "\n"
		"SBMLExternalValidator_getNumArguments(SBMLExternalValidator self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExternalValidator_getArgument", _wrap_SBMLExternalValidator_getArgument, METH_VARARGS, "\n"
		"SBMLExternalValidator_getArgument(SBMLExternalValidator self, unsigned int n) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExternalValidator_swigregister", SBMLExternalValidator_swigregister, METH_O, NULL},
	 { "SBMLExternalValidator_swiginit", SBMLExternalValidator_swiginit, METH_VARARGS, NULL},
	 { "delete_XMLAttributes", _wrap_delete_XMLAttributes, METH_O, "delete_XMLAttributes(XMLAttributes self)"},
	 { "new_XMLAttributes", _wrap_new_XMLAttributes, METH_VARARGS, "\n"
		"XMLAttributes()\n"
		"new_XMLAttributes(XMLAttributes orig) -> XMLAttributes\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLAttributes()\n"
		"\n"
		"Creates a new, empty XMLAttributes object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLAttributes(XMLAttributes orig)\n"
		"\n"
		"Copy constructor; creates a copy of this XMLAttributes object.\n"
		"\n"
		"'orig' the XMLAttributes object to copy.\n"
		"\n"
		""},
	 { "XMLAttributes_clone", _wrap_XMLAttributes_clone, METH_O, "\n"
		"XMLAttributes_clone(XMLAttributes self) -> XMLAttributes\n"
		"\n"
		"Creates and returns a deep copy of this XMLAttributes object.\n"
		"\n"
		"Returns the (deep) copy of this XMLAttributes object.\n"
		"\n"
		""},
	 { "XMLAttributes_add", _wrap_XMLAttributes_add, METH_VARARGS, "\n"
		"XMLAttributes_add(XMLAttributes self, string name, string value, string namespaceURI=\"\", string prefix=\"\") -> int\n"
		"XMLAttributes_add(XMLAttributes self, XMLTriple triple, string value) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    add(  string name , string value , string namespaceURI = '' ,\n"
		"string prefix = '')\n"
		"\n"
		"Adds an attribute to this list of attributes.\n"
		"\n"
		"Some explanations are in order about the behavior of XMLAttributes\n"
		"with respect to namespace prefixes and namespace URIs.  XMLAttributes\n"
		"does not verify the consistency of different uses of an XML namespace\n"
		"and the prefix used to refer to it in a given context.  It cannot,\n"
		"because the prefix used for a given XML namespace in an XML document\n"
		"may intentionally be different on different elements in the document.\n"
		"Consequently, callers need to manage their own prefix-to-namespace\n"
		"mappings, and need to ensure that the desired prefix is used in any\n"
		"given context.\n"
		"\n"
		"When called with attribute names, prefixes and namespace URIs,\n"
		"XMLAttributes pays attention to the namespace URIs and not the\n"
		"prefixes: a match is established by a combination of attribute name\n"
		"and namespace URI, and if on different occasions a different prefix is\n"
		"used for the same name/namespace combination, the prefix associated\n"
		"with the namespace on that attribute is overwritten.\n"
		"\n"
		"Some examples will hopefully clarify this.  Here are the results of a\n"
		"sequence of calls to the XMLAttributes add methods with different\n"
		"argument combinations.  First, we create the object and add one\n"
		"attribute:\n"
		"\n"
		"  XMLAttributes  att = new XMLAttributes();\n"
		"  att->add('myattribute', '1', 'myuri');\n"
		"\n"
		"The above adds an attribute named myattribute in the namespace myuri,\n"
		"and with the attribute value 1.  No namespace prefix is associated\n"
		"with the attribute (but the attribute is recorded to exist in the\n"
		"namespace myuri).  If this attribute object were written out in XML,\n"
		"it would look like the following (and note that, since no namespace\n"
		"prefix was assigned, none is written out): <center>\n"
		"\n"
		"  myattribute='1'\n"
		"\n"
		"</center>\n"
		"\n"
		"Continuing with this series of examples, suppose we invoke the add\n"
		"method again as follows:\n"
		"\n"
		"  att->add('myattribute', '2');\n"
		"\n"
		"The above adds a new attribute also named myattribute, but in a\n"
		"different XML namespace: it is placed in the namespace with no URI,\n"
		"which is to say, the default XML namespace.  Both attributes coexist\n"
		"on this XMLAttributes object; both can be independently retrieved.\n"
		"\n"
		"  att->add('myattribute', '3');\n"
		"\n"
		"The code above now replaces the value of the attribute myattribute\n"
		"that resides in the default namespace.  The attribute in the namespace\n"
		"myuri remains untouched.\n"
		"\n"
		"  att->add('myattribute', '4', 'myuri');\n"
		"\n"
		"The code above replaces the value of the attribute myattribute that\n"
		"resides in the myuri namespace. The attribute in the default namespace\n"
		"remains untouched.\n"
		"\n"
		"  att->add('myattribute', '5', 'myuri', 'foo');\n"
		"\n"
		"The code above replaces the value of the attribute myattribute that\n"
		"resides in the myuri namespace. It also now assigns a namespace\n"
		"prefix, foo, to the attribute. The attribute myattribute in the\n"
		"default namespace remains untouched. If this XMLAttributes object were\n"
		"written out in XML, it would look like the following: <center>\n"
		"\n"
		"  myattribute='3'\n"
		"  foo:myattribute='5'\n"
		"\n"
		"</center> Pressing on, now suppose we call the add method as follows:\n"
		"\n"
		"  att->add('myattribute', '6', 'myuri', 'bar');\n"
		"\n"
		"The code above replaces the value of the attribute myattribute that\n"
		"resides in the myuri namespace. It also assigns a different prefix to\n"
		"the attribute.  The namespace of the attribute remains myuri.\n"
		"\n"
		"  att->add('myattribute', '7', '', 'foo');\n"
		"\n"
		"The code above replaces the value of the attribute myattribute that\n"
		"resides in the default namespace.  It also now assigns a namespace\n"
		"prefix, foo, to that attribute.  If this XMLAttributes object were\n"
		"written out in XML, it would look like the following: <center>\n"
		"\n"
		"  bar:myattribute='6'\n"
		"  foo:myattribute='7'\n"
		"\n"
		"</center>\n"
		"\n"
		"Parameter 'name' is a string, the unprefixed name of the attribute.\n"
		"Parameter 'value' is a string, the value of the attribute. Parameter\n"
		"'namespaceURI' is a string, the namespace URI of the attribute.\n"
		"Parameter 'prefix' is a string, a prefix for the XML namespace.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT - this value is returned if any of the\n"
		"arguments are 'None.'  To set an empty 'prefix' and/or 'name' value,\n"
		"use an empty string rather than 'None.'\n"
		"\n"
		"Note: If an attribute with the same name and XML namespace URI already\n"
		"exists in the list of attributes held by this XMLAttributes object,\n"
		"then the previous value of that attribute will be replaced with the\n"
		"new value provided to this method.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"See also add(), getIndex(), getIndex(), hasAttribute(),\n"
		"hasAttribute().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    add( XMLTriple triple, string value)\n"
		"\n"
		"Adds an attribute to this list of attributes.\n"
		"\n"
		"Some explanations are in order about the behavior of XMLAttributes\n"
		"with respect to namespace prefixes and namespace URIs.  XMLAttributes\n"
		"does not verify the consistency of different uses of an XML namespace\n"
		"and the prefix used to refer to it in a given context.  It cannot,\n"
		"because the prefix used for a given XML namespace in an XML document\n"
		"may intentionally be different on different elements in the document.\n"
		"Consequently, callers need to manage their own prefix-to-namespace\n"
		"mappings, and need to ensure that the desired prefix is used in any\n"
		"given context.\n"
		"\n"
		"When called with attribute names, prefixes and namespace URIs,\n"
		"XMLAttributes pays attention to the namespace URIs and not the\n"
		"prefixes: a match is established by a combination of attribute name\n"
		"and namespace URI, and if on different occasions a different prefix is\n"
		"used for the same name/namespace combination, the prefix associated\n"
		"with the namespace on that attribute is overwritten.\n"
		"\n"
		"Some examples will hopefully clarify this.  Here are the results of a\n"
		"sequence of calls to the XMLAttributes add methods with different\n"
		"argument combinations.  First, we create the object and add one\n"
		"attribute:\n"
		"\n"
		"  XMLAttributes  att = new XMLAttributes();\n"
		"  att->add('myattribute', '1', 'myuri');\n"
		"\n"
		"The above adds an attribute named myattribute in the namespace myuri,\n"
		"and with the attribute value 1.  No namespace prefix is associated\n"
		"with the attribute (but the attribute is recorded to exist in the\n"
		"namespace myuri).  If this attribute object were written out in XML,\n"
		"it would look like the following (and note that, since no namespace\n"
		"prefix was assigned, none is written out): <center>\n"
		"\n"
		"  myattribute='1'\n"
		"\n"
		"</center>\n"
		"\n"
		"Continuing with this series of examples, suppose we invoke the add\n"
		"method again as follows:\n"
		"\n"
		"  att->add('myattribute', '2');\n"
		"\n"
		"The above adds a new attribute also named myattribute, but in a\n"
		"different XML namespace: it is placed in the namespace with no URI,\n"
		"which is to say, the default XML namespace.  Both attributes coexist\n"
		"on this XMLAttributes object; both can be independently retrieved.\n"
		"\n"
		"  att->add('myattribute', '3');\n"
		"\n"
		"The code above now replaces the value of the attribute myattribute\n"
		"that resides in the default namespace.  The attribute in the namespace\n"
		"myuri remains untouched.\n"
		"\n"
		"  att->add('myattribute', '4', 'myuri');\n"
		"\n"
		"The code above replaces the value of the attribute myattribute that\n"
		"resides in the myuri namespace. The attribute in the default namespace\n"
		"remains untouched.\n"
		"\n"
		"  att->add('myattribute', '5', 'myuri', 'foo');\n"
		"\n"
		"The code above replaces the value of the attribute myattribute that\n"
		"resides in the myuri namespace. It also now assigns a namespace\n"
		"prefix, foo, to the attribute. The attribute myattribute in the\n"
		"default namespace remains untouched. If this XMLAttributes object were\n"
		"written out in XML, it would look like the following: <center>\n"
		"\n"
		"  myattribute='3'\n"
		"  foo:myattribute='5'\n"
		"\n"
		"</center> Pressing on, now suppose we call the add method as follows:\n"
		"\n"
		"  att->add('myattribute', '6', 'myuri', 'bar');\n"
		"\n"
		"The code above replaces the value of the attribute myattribute that\n"
		"resides in the myuri namespace. It also assigns a different prefix to\n"
		"the attribute.  The namespace of the attribute remains myuri.\n"
		"\n"
		"  att->add('myattribute', '7', '', 'foo');\n"
		"\n"
		"The code above replaces the value of the attribute myattribute that\n"
		"resides in the default namespace.  It also now assigns a namespace\n"
		"prefix, foo, to that attribute.  If this XMLAttributes object were\n"
		"written out in XML, it would look like the following: <center>\n"
		"\n"
		"  bar:myattribute='6'\n"
		"  foo:myattribute='7'\n"
		"\n"
		"</center>\n"
		"\n"
		"Parameter 'triple' is an XMLTriple object describing the attribute to\n"
		"be added. Parameter 'value' is a string, the value of the attribute.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT - this value is returned if any of the\n"
		"arguments are 'None.'  To set an empty value for the attribute, use an\n"
		"empty string rather than 'None.'\n"
		"\n"
		"Note: If an attribute with the same name and XML namespace URI already\n"
		"exists in the list of attributes held by this XMLAttributes object,\n"
		"then the previous value of that attribute will be replaced with the\n"
		"new value provided to this method.\n"
		"\n"
		"See also add(), getIndex(), getIndex(), hasAttribute(),\n"
		"hasAttribute().\n"
		"\n"
		""},
	 { "XMLAttributes_removeResource", _wrap_XMLAttributes_removeResource, METH_VARARGS, "\n"
		"XMLAttributes_removeResource(XMLAttributes self, int n) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "XMLAttributes_remove", _wrap_XMLAttributes_remove, METH_VARARGS, "\n"
		"XMLAttributes_remove(XMLAttributes self, int n) -> int\n"
		"XMLAttributes_remove(XMLAttributes self, string name, string uri=\"\") -> int\n"
		"XMLAttributes_remove(XMLAttributes self, XMLTriple triple) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string name, string uri = '')\n"
		"\n"
		"Removes a named attribute from this list of attributes.\n"
		"\n"
		"Parameter 'name' is a string, the unprefixed name of the attribute to\n"
		"be removed.\n"
		"\n"
		"Parameter 'uri' is a string, the namespace URI of the attribute to be\n"
		"removed.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no\n"
		"attribute with the given 'name' (and 'uri' if specified).\n"
		"\n"
		"See also remove(), remove().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(int n)\n"
		"\n"
		"Removes the nth attribute from this list of attributes.\n"
		"\n"
		"Parameter 'n' is an integer the index of the resource to be deleted.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no\n"
		"attribute at the given index 'n'.\n"
		"\n"
		"Note: Note that although XMLAttributes provides operations that can\n"
		"manipulate attributes based on a numerical index, XML attributes are\n"
		"in fact unordered when they appear in files and data streams.  The\n"
		"XMLAttributes class provides some list-like facilities, but it is only\n"
		"for the convenience of callers.  (For example, it permits callers to\n"
		"loop across all attributes more easily.)  Users should keep in mind\n"
		"that the order in which attributes are stored in XMLAttributes objects\n"
		"has no real impact on the order in which the attributes are read or\n"
		"written from an XML file or data stream.\n"
		"\n"
		"See also getLength(), remove(), remove().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(XMLTriple triple)\n"
		"\n"
		"Removes a specific attribute from this list of attributes.\n"
		"\n"
		"Parameter 'triple' is an XMLTriple describing the attribute to be\n"
		"removed.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no\n"
		"attribute matching the properties of the given 'triple'.\n"
		"\n"
		"See also remove(), remove().\n"
		"\n"
		""},
	 { "XMLAttributes_clear", _wrap_XMLAttributes_clear, METH_O, "\n"
		"XMLAttributes_clear(XMLAttributes self) -> int\n"
		"\n"
		"Removes all attributes in this XMLAttributes object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also remove(), remove(), remove().\n"
		"\n"
		""},
	 { "XMLAttributes_getIndex", _wrap_XMLAttributes_getIndex, METH_VARARGS, "\n"
		"XMLAttributes_getIndex(XMLAttributes self, string name) -> int\n"
		"XMLAttributes_getIndex(XMLAttributes self, string name, string uri) -> int\n"
		"XMLAttributes_getIndex(XMLAttributes self, XMLTriple triple) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getIndex(XMLTriple triple)\n"
		"\n"
		"Returns the index of the attribute defined by the given XMLTriple\n"
		"object.\n"
		"\n"
		"Parameter 'triple' is an XMLTriple describing the attribute being\n"
		"sought.\n"
		"\n"
		"Returns the index of an attribute described by the given XMLTriple\n"
		"object, or -1 if no such attribute is present.\n"
		"\n"
		"See also hasAttribute(), hasAttribute().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getIndex(string name, string uri)\n"
		"\n"
		"Returns the index of the attribute having a given name and XML\n"
		"namespace URI.\n"
		"\n"
		"Parameter 'name' is a string, the name of the attribute being sought.\n"
		"Parameter 'uri' is a string, the namespace URI of the attribute being\n"
		"sought.\n"
		"\n"
		"Returns the index of an attribute with the given local name and\n"
		"namespace URI, or -1 if no such attribute is present.\n"
		"\n"
		"See also hasAttribute(), hasAttribute().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getIndex(string name)\n"
		"\n"
		"Returns the index of an attribute having a given name.\n"
		"\n"
		"Note: This method does not check XML namespaces.  Thus, if there are\n"
		"multiple attributes with the same local 'name' but different\n"
		"namespaces, this method will return the first one found.  Callers\n"
		"should use the more specific methods XMLAttributes.getIndex()  or\n"
		"XMLAttributes.getIndex()  to find attributes in particular namespaces.\n"
		"\n"
		"Parameter 'name' is a string, the name of the attribute whose index is\n"
		"begin sought.\n"
		"\n"
		"Returns the index of an attribute with the given local name, or -1 if\n"
		"no such attribute is present.\n"
		"\n"
		"See also hasAttribute(), hasAttribute().\n"
		"\n"
		""},
	 { "XMLAttributes_getLength", _wrap_XMLAttributes_getLength, METH_O, "\n"
		"XMLAttributes_getLength(XMLAttributes self) -> int\n"
		"\n"
		"Returns the number of attributes in this list of attributes.\n"
		"\n"
		"Returns the number of attributes contained in this XMLAttributes\n"
		"object.\n"
		"\n"
		""},
	 { "XMLAttributes_getNumAttributes", _wrap_XMLAttributes_getNumAttributes, METH_O, "\n"
		"XMLAttributes_getNumAttributes(XMLAttributes self) -> int\n"
		"\n"
		"Returns the number of attributes in this list of attributes.\n"
		"\n"
		"This function is merely an alias of XMLAttributes.getLength()\n"
		"introduced for consistency with other libXML classes.\n"
		"\n"
		"Returns the number of attributes contained in this XMLAttributes\n"
		"object.\n"
		"\n"
		""},
	 { "XMLAttributes_getName", _wrap_XMLAttributes_getName, METH_VARARGS, "\n"
		"XMLAttributes_getName(XMLAttributes self, int index) -> string\n"
		"\n"
		"Returns the name of the nth attribute in this list of attributes.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the attribute whose\n"
		"name is being sought.\n"
		"\n"
		"Returns the local name of the nth attribute.\n"
		"\n"
		"Note: If 'index' is out of range, this method will return an empty\n"
		"string.  Callers should use XMLAttributes.getLength() to check the\n"
		"number of attributes contained in this object or\n"
		"XMLAttributes.hasAttribute()  to test for the existence of an\n"
		"attribute at a given position.\n"
		"\n"
		"Note: Note that although XMLAttributes provides operations that can\n"
		"manipulate attributes based on a numerical index, XML attributes are\n"
		"in fact unordered when they appear in files and data streams.  The\n"
		"XMLAttributes class provides some list-like facilities, but it is only\n"
		"for the convenience of callers.  (For example, it permits callers to\n"
		"loop across all attributes more easily.)  Users should keep in mind\n"
		"that the order in which attributes are stored in XMLAttributes objects\n"
		"has no real impact on the order in which the attributes are read or\n"
		"written from an XML file or data stream.\n"
		"\n"
		"See also getLength(), hasAttribute().\n"
		"\n"
		""},
	 { "XMLAttributes_getPrefix", _wrap_XMLAttributes_getPrefix, METH_VARARGS, "\n"
		"XMLAttributes_getPrefix(XMLAttributes self, int index) -> string\n"
		"\n"
		"Returns the namespace prefix of the nth attribute in this attribute\n"
		"set.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the attribute whose\n"
		"namespace prefix is being sought.\n"
		"\n"
		"Returns the XML namespace prefix of the nth attribute.\n"
		"\n"
		"Note: If 'index' is out of range, this method will return an empty\n"
		"string.  Callers should use XMLAttributes.getLength() to check the\n"
		"number of attributes contained in this object or\n"
		"XMLAttributes.hasAttribute()  to test for the existence of an\n"
		"attribute at a given position.\n"
		"\n"
		"Note: Note that although XMLAttributes provides operations that can\n"
		"manipulate attributes based on a numerical index, XML attributes are\n"
		"in fact unordered when they appear in files and data streams.  The\n"
		"XMLAttributes class provides some list-like facilities, but it is only\n"
		"for the convenience of callers.  (For example, it permits callers to\n"
		"loop across all attributes more easily.)  Users should keep in mind\n"
		"that the order in which attributes are stored in XMLAttributes objects\n"
		"has no real impact on the order in which the attributes are read or\n"
		"written from an XML file or data stream.\n"
		"\n"
		"See also getLength(), hasAttribute().\n"
		"\n"
		""},
	 { "XMLAttributes_getPrefixedName", _wrap_XMLAttributes_getPrefixedName, METH_VARARGS, "\n"
		"XMLAttributes_getPrefixedName(XMLAttributes self, int index) -> string\n"
		"\n"
		"Returns the prefix name of the nth attribute in this attribute set.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the attribute whose\n"
		"prefixed name is being sought.\n"
		"\n"
		"Returns the prefixed name of the nth attribute.\n"
		"\n"
		"Note: If 'index' is out of range, this method will return an empty\n"
		"string.  Callers should use XMLAttributes.getLength() to check the\n"
		"number of attributes contained in this object or\n"
		"XMLAttributes.hasAttribute()  to test for the existence of an\n"
		"attribute at a given position.\n"
		"\n"
		"Note: Note that although XMLAttributes provides operations that can\n"
		"manipulate attributes based on a numerical index, XML attributes are\n"
		"in fact unordered when they appear in files and data streams.  The\n"
		"XMLAttributes class provides some list-like facilities, but it is only\n"
		"for the convenience of callers.  (For example, it permits callers to\n"
		"loop across all attributes more easily.)  Users should keep in mind\n"
		"that the order in which attributes are stored in XMLAttributes objects\n"
		"has no real impact on the order in which the attributes are read or\n"
		"written from an XML file or data stream.\n"
		"\n"
		"See also getLength(), hasAttribute().\n"
		"\n"
		""},
	 { "XMLAttributes_getURI", _wrap_XMLAttributes_getURI, METH_VARARGS, "\n"
		"XMLAttributes_getURI(XMLAttributes self, int index) -> string\n"
		"\n"
		"Returns the XML namespace URI of the nth attribute in this attribute\n"
		"set.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the attribute whose\n"
		"namespace URI is being sought.\n"
		"\n"
		"Returns the XML namespace URI of the nth attribute.\n"
		"\n"
		"Note: If 'index' is out of range, this method will return an empty\n"
		"string.  Callers should use XMLAttributes.getLength() to check the\n"
		"number of attributes contained in this object or\n"
		"XMLAttributes.hasAttribute()  to test for the existence of an\n"
		"attribute at a given position.\n"
		"\n"
		"Note: Note that although XMLAttributes provides operations that can\n"
		"manipulate attributes based on a numerical index, XML attributes are\n"
		"in fact unordered when they appear in files and data streams.  The\n"
		"XMLAttributes class provides some list-like facilities, but it is only\n"
		"for the convenience of callers.  (For example, it permits callers to\n"
		"loop across all attributes more easily.)  Users should keep in mind\n"
		"that the order in which attributes are stored in XMLAttributes objects\n"
		"has no real impact on the order in which the attributes are read or\n"
		"written from an XML file or data stream.\n"
		"\n"
		"See also getLength(), hasAttribute().\n"
		"\n"
		""},
	 { "XMLAttributes_getValue", _wrap_XMLAttributes_getValue, METH_VARARGS, "\n"
		"XMLAttributes_getValue(XMLAttributes self, int index) -> string\n"
		"XMLAttributes_getValue(XMLAttributes self, string name) -> string\n"
		"XMLAttributes_getValue(XMLAttributes self, string name, string uri) -> string\n"
		"XMLAttributes_getValue(XMLAttributes self, XMLTriple triple) -> string\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getValue(XMLTriple triple)\n"
		"\n"
		"Return the value of an attribute described by a given XMLTriple\n"
		"object.\n"
		"\n"
		"Parameter 'triple' is an XMLTriple describing the attribute whose\n"
		"value is being sought.\n"
		"\n"
		"Returns The attribute value as a string.\n"
		"\n"
		"Note: If an attribute with the properties given by 'triple' does not\n"
		"exist in this XMLAttributes object, this method will return an empty\n"
		"string.  Callers can use XMLAttributes.hasAttribute()  to test for an\n"
		"attribute's existence.\n"
		"\n"
		"See also hasAttribute(), hasAttribute().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getValue(int index)\n"
		"\n"
		"Returns the value of the nth attribute in this list of attributes.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the attribute whose\n"
		"value is being sought.\n"
		"\n"
		"Returns the XML value of the nth attribute.\n"
		"\n"
		"Note: If 'index' is out of range, this method will return an empty\n"
		"string.  Callers should use XMLAttributes.getLength() to check the\n"
		"number of attributes contained in this object or\n"
		"XMLAttributes.hasAttribute()  to test for the existence of an\n"
		"attribute at a given position.\n"
		"\n"
		"Note: Note that although XMLAttributes provides operations that can\n"
		"manipulate attributes based on a numerical index, XML attributes are\n"
		"in fact unordered when they appear in files and data streams.  The\n"
		"XMLAttributes class provides some list-like facilities, but it is only\n"
		"for the convenience of callers.  (For example, it permits callers to\n"
		"loop across all attributes more easily.)  Users should keep in mind\n"
		"that the order in which attributes are stored in XMLAttributes objects\n"
		"has no real impact on the order in which the attributes are read or\n"
		"written from an XML file or data stream.\n"
		"\n"
		"See also getLength(), hasAttribute().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getValue(string name)\n"
		"\n"
		"Returns a named attribute's value.\n"
		"\n"
		"Parameter 'name' is a string, the unprefixed name of the attribute\n"
		"whose value is being sought.\n"
		"\n"
		"Returns The attribute value as a string.\n"
		"\n"
		"Note: If an attribute with the given local 'name' does not exist in\n"
		"this XMLAttributes object, this method will return an empty string.\n"
		"Callers can use XMLAttributes.hasAttribute()  to test for an\n"
		"attribute's existence.  This method also does not check the XML\n"
		"namespace of the named attribute.  Thus, if there are multiple\n"
		"attributes with the same local 'name' but different namespaces, this\n"
		"method will return the value of the first such attribute found.\n"
		"Callers should use the more specific methods XMLAttributes.getIndex()\n"
		"or XMLAttributes.getIndex()  to find attributes in particular\n"
		"namespaces.\n"
		"\n"
		"See also hasAttribute(), hasAttribute().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getValue(string name, string uri)\n"
		"\n"
		"Returns a named attribute's value.\n"
		"\n"
		"Parameter 'name' is a string, the name of the attribute whose value is\n"
		"being sought. Parameter 'uri' is a string, the XML namespace URI of\n"
		"the attribute.\n"
		"\n"
		"Returns The attribute value as a string.\n"
		"\n"
		"Note: If an attribute with the given 'name' and namespace 'uri' does\n"
		"not exist in this XMLAttributes object, this method will return an\n"
		"empty string.  Callers can use XMLAttributes.hasAttribute()  to test\n"
		"for an attribute's existence.\n"
		"\n"
		"See also hasAttribute(), hasAttribute().\n"
		"\n"
		""},
	 { "XMLAttributes_hasAttribute", _wrap_XMLAttributes_hasAttribute, METH_VARARGS, "\n"
		"XMLAttributes_hasAttribute(XMLAttributes self, int index) -> bool\n"
		"XMLAttributes_hasAttribute(XMLAttributes self, string name, string uri=\"\") -> bool\n"
		"XMLAttributes_hasAttribute(XMLAttributes self, XMLTriple triple) -> bool\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    hasAttribute(string name, string uri='')\n"
		"\n"
		"Returns 'True' if an attribute with a given name and namespace URI\n"
		"exists.\n"
		"\n"
		"Parameter 'name' is a string, the unprefixed name of the attribute.\n"
		"Parameter 'uri' is a string, the XML namespace URI of the attribute.\n"
		"\n"
		"Returns 'True' if an attribute with the given local name and XML\n"
		"namespace URI exists in this XMLAttributes object, 'False' otherwise.\n"
		"\n"
		"See also add(), add().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    hasAttribute(XMLTriple triple)\n"
		"\n"
		"Returns 'True' if an attribute with the given properties exists.\n"
		"\n"
		"Parameter 'triple' is an XMLTriple describing the attribute to be\n"
		"tested.\n"
		"\n"
		"Returns 'True' if an attribute with the given XML triple exists in\n"
		"this XMLAttributes object, 'False' otherwise.\n"
		"\n"
		"See also add(), add().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    hasAttribute(int index)\n"
		"\n"
		"Returns 'True' if an attribute exists at a given index.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the attribute to be\n"
		"tested.\n"
		"\n"
		"Returns 'True' if an attribute with the given index exists in this\n"
		"XMLAttributes object, 'False' otherwise.\n"
		"\n"
		"Note: Note that although XMLAttributes provides operations that can\n"
		"manipulate attributes based on a numerical index, XML attributes are\n"
		"in fact unordered when they appear in files and data streams.  The\n"
		"XMLAttributes class provides some list-like facilities, but it is only\n"
		"for the convenience of callers.  (For example, it permits callers to\n"
		"loop across all attributes more easily.)  Users should keep in mind\n"
		"that the order in which attributes are stored in XMLAttributes objects\n"
		"has no real impact on the order in which the attributes are read or\n"
		"written from an XML file or data stream.\n"
		"\n"
		""},
	 { "XMLAttributes_isEmpty", _wrap_XMLAttributes_isEmpty, METH_O, "\n"
		"XMLAttributes_isEmpty(XMLAttributes self) -> bool\n"
		"\n"
		"Returns 'True' if this list of attributes is empty.\n"
		"\n"
		"Returns 'True' if this XMLAttributes object is empty, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "XMLAttributes_swigregister", XMLAttributes_swigregister, METH_O, NULL},
	 { "XMLAttributes_swiginit", XMLAttributes_swiginit, METH_VARARGS, NULL},
	 { "delete_XMLNamespaces", _wrap_delete_XMLNamespaces, METH_O, "delete_XMLNamespaces(XMLNamespaces self)"},
	 { "new_XMLNamespaces", _wrap_new_XMLNamespaces, METH_VARARGS, "\n"
		"XMLNamespaces()\n"
		"new_XMLNamespaces(XMLNamespaces orig) -> XMLNamespaces\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLNamespaces()\n"
		"\n"
		"Creates a new empty list of XML namespace declarations.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLNamespaces(XMLNamespaces orig)\n"
		"\n"
		"Copy constructor; creates a copy of this XMLNamespaces list.\n"
		"\n"
		"Parameter 'orig' is the XMLNamespaces object to copy.\n"
		"\n"
		""},
	 { "XMLNamespaces_clone", _wrap_XMLNamespaces_clone, METH_O, "\n"
		"XMLNamespaces_clone(XMLNamespaces self) -> XMLNamespaces\n"
		"\n"
		"Creates and returns a deep copy of this XMLNamespaces object.\n"
		"\n"
		"Returns the (deep) copy of this XMLNamespaces object.\n"
		"\n"
		""},
	 { "XMLNamespaces_add", _wrap_XMLNamespaces_add, METH_VARARGS, "\n"
		"XMLNamespaces_add(XMLNamespaces self, string uri, string prefix=\"\") -> int\n"
		"\n"
		"Appends an XML namespace prefix and URI pair to this list of namespace\n"
		"declarations.\n"
		"\n"
		"An XMLNamespaces object stores a list of pairs of namespaces and their\n"
		"prefixes.  If there is an XML namespace with the given 'uri' prefix in\n"
		"this list, then its corresponding URI will be overwritten by the new\n"
		"'uri' unless the uri represents the core sbml namespace. Calling\n"
		"programs could use one of the other XMLNamespaces methods, such as\n"
		"XMLNamespaces.hasPrefix() and  XMLNamespaces.hasURI() to inquire\n"
		"whether a given prefix and/or URI is already present in this\n"
		"XMLNamespaces object. If the 'uri' represents the sbml namespaces then\n"
		"it will not be overwritten, as this has potentially serious\n"
		"consequences. If it is necessary to replace the sbml namespace the\n"
		"namespace should be removed prior to adding the new namespace.\n"
		"\n"
		"Parameter 'uri' is a string, the uri for the namespace. Parameter\n"
		"'prefix' is a string, the prefix for the namespace.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "XMLNamespaces_remove", _wrap_XMLNamespaces_remove, METH_VARARGS, "\n"
		"XMLNamespaces_remove(XMLNamespaces self, int index) -> int\n"
		"XMLNamespaces_remove(XMLNamespaces self, string prefix) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(int index)\n"
		"\n"
		"Removes an XML Namespace stored in the given position of this list.\n"
		"\n"
		"Parameter 'index' is an integer, position of the namespace to remove.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    remove(string prefix)\n"
		"\n"
		"Removes an XML Namespace with the given prefix.\n"
		"\n"
		"Parameter 'prefix' is a string, prefix of the required namespace.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"See also remove().\n"
		"\n"
		""},
	 { "XMLNamespaces_clear", _wrap_XMLNamespaces_clear, METH_O, "\n"
		"XMLNamespaces_clear(XMLNamespaces self) -> int\n"
		"\n"
		"Clears (deletes) all XML namespace declarations in this XMLNamespaces\n"
		"object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also remove().\n"
		"\n"
		""},
	 { "XMLNamespaces_getIndex", _wrap_XMLNamespaces_getIndex, METH_VARARGS, "\n"
		"XMLNamespaces_getIndex(XMLNamespaces self, string uri) -> int\n"
		"\n"
		"Look up the index of an XML namespace declaration by URI.\n"
		"\n"
		"An XMLNamespaces object stores a list of pairs of namespaces and their\n"
		"prefixes.  If this XMLNamespaces object contains a pair with the given\n"
		"URI 'uri', this method returns its index in the list.\n"
		"\n"
		"Parameter 'uri' is a string, the URI of the sought-after namespace.\n"
		"\n"
		"Returns the index of the given declaration, or -1 if not present.\n"
		"\n"
		""},
	 { "XMLNamespaces_containsUri", _wrap_XMLNamespaces_containsUri, METH_VARARGS, "\n"
		"XMLNamespaces_containsUri(XMLNamespaces self, string uri) -> bool\n"
		"\n"
		"Tests whether the given uri is contained in this set of namespaces.\n"
		"\n"
		""},
	 { "XMLNamespaces_getIndexByPrefix", _wrap_XMLNamespaces_getIndexByPrefix, METH_VARARGS, "\n"
		"XMLNamespaces_getIndexByPrefix(XMLNamespaces self, string prefix) -> int\n"
		"\n"
		"Look up the index of an XML namespace declaration by 'prefix'.\n"
		"\n"
		"An XMLNamespaces object stores a list of pairs of namespaces and their\n"
		"prefixes.  If this XMLNamespaces object contains a pair with the given\n"
		"prefix 'prefix', this method returns its index in the list.\n"
		"\n"
		"Parameter 'prefix' is a string, the prefix string of the sought-after\n"
		"namespace.\n"
		"\n"
		"Returns the index of the given declaration, or -1 if not present.\n"
		"\n"
		""},
	 { "XMLNamespaces_getLength", _wrap_XMLNamespaces_getLength, METH_O, "\n"
		"XMLNamespaces_getLength(XMLNamespaces self) -> int\n"
		"\n"
		"Returns the total number of URI-and-prefix pairs stored in this\n"
		"particular XMLNamespaces instance.\n"
		"\n"
		"Returns the number of namespaces in this list.\n"
		"\n"
		""},
	 { "XMLNamespaces_getNumNamespaces", _wrap_XMLNamespaces_getNumNamespaces, METH_O, "\n"
		"XMLNamespaces_getNumNamespaces(XMLNamespaces self) -> int\n"
		"\n"
		"Returns the total number of URI-and-prefix pairs stored in this\n"
		"particular XMLNamespaces instance.\n"
		"\n"
		"Returns the number of namespaces in this list.\n"
		"\n"
		"This function is an alias for getLength introduced for consistency\n"
		"with other XML classes.\n"
		"\n"
		""},
	 { "XMLNamespaces_getPrefix", _wrap_XMLNamespaces_getPrefix, METH_VARARGS, "\n"
		"XMLNamespaces_getPrefix(XMLNamespaces self, int index) -> string\n"
		"XMLNamespaces_getPrefix(XMLNamespaces self, string uri) -> string\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getPrefix(int index)\n"
		"\n"
		"Look up the prefix of an XML namespace declaration by its position.\n"
		"\n"
		"An XMLNamespaces object stores a list of pairs of namespaces and their\n"
		"prefixes.  This method returns the prefix of the nth element in that\n"
		"list (if it exists).  Callers should use XMLAttributes.getLength()\n"
		"first to find out how many namespaces are stored in the list.\n"
		"\n"
		"Parameter 'index' is an integer, position of the sought-after prefix.\n"
		"\n"
		"Returns the prefix of an XML namespace declaration in this list (by\n"
		"position), or an empty string if the 'index' is out of range.\n"
		"\n"
		"See also getLength().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getPrefix(string uri)\n"
		"\n"
		"Look up the prefix of an XML namespace declaration by its URI.\n"
		"\n"
		"An XMLNamespaces object stores a list of pairs of namespaces and their\n"
		"prefixes.  This method returns the prefix for a pair that has the\n"
		"given 'uri'.\n"
		"\n"
		"Parameter 'uri' is a string, the URI of the prefix being sought.\n"
		"\n"
		"Returns the prefix of an XML namespace declaration given its URI, or\n"
		"an empty string if no such 'uri' exists in this XMLNamespaces object.\n"
		"\n"
		""},
	 { "XMLNamespaces_getURI", _wrap_XMLNamespaces_getURI, METH_VARARGS, "\n"
		"XMLNamespaces_getURI(XMLNamespaces self, int index) -> string\n"
		"XMLNamespaces_getURI(XMLNamespaces self, string prefix=\"\") -> string\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getURI(string prefix = '')\n"
		"\n"
		"Look up the URI of an XML namespace declaration by its prefix.\n"
		"\n"
		"An XMLNamespaces object stores a list of pairs of namespaces and their\n"
		"prefixes.  This method returns the namespace URI for a pair that has\n"
		"the given 'prefix'.\n"
		"\n"
		"Parameter 'prefix' is a string, the prefix of the required URI.\n"
		"\n"
		"Returns the URI of an XML namespace declaration having the given\n"
		"'prefix', or an empty string if no such prefix-and-URI pair exists in\n"
		"this XMLNamespaces object.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"See also getURI().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getURI(int index)\n"
		"\n"
		"Look up the URI of an XML namespace declaration by its position.\n"
		"\n"
		"An XMLNamespaces object stores a list of pairs of namespaces and their\n"
		"prefixes.  This method returns the URI of the nth element in that list\n"
		"(if it exists).  Callers should use XMLAttributes.getLength() first to\n"
		"find out how many namespaces are stored in the list.\n"
		"\n"
		"Parameter 'index' is an integer, position of the required URI.\n"
		"\n"
		"Returns the URI of an XML namespace declaration in this list (by\n"
		"position), or an empty string if the 'index' is out of range.\n"
		"\n"
		"See also getLength().\n"
		"\n"
		""},
	 { "XMLNamespaces_isEmpty", _wrap_XMLNamespaces_isEmpty, METH_O, "\n"
		"XMLNamespaces_isEmpty(XMLNamespaces self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this\n"
		"XMLNamespaces list is empty.\n"
		"\n"
		"Returns 'True' if this XMLNamespaces list is empty, 'False' otherwise.\n"
		"\n"
		""},
	 { "XMLNamespaces_hasURI", _wrap_XMLNamespaces_hasURI, METH_VARARGS, "\n"
		"XMLNamespaces_hasURI(XMLNamespaces self, string uri) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether an XML\n"
		"Namespace with the given URI is contained in this XMLNamespaces list.\n"
		"\n"
		"Parameter 'uri' is a string, the uri for the namespace.\n"
		"\n"
		"Returns 'True' if an XML Namespace with the given URI is contained in\n"
		"this XMLNamespaces list, 'False' otherwise.\n"
		"\n"
		""},
	 { "XMLNamespaces_hasPrefix", _wrap_XMLNamespaces_hasPrefix, METH_VARARGS, "\n"
		"XMLNamespaces_hasPrefix(XMLNamespaces self, string prefix) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether an XML\n"
		"Namespace with the given prefix is contained in this XMLNamespaces\n"
		"list.\n"
		"\n"
		"Parameter 'prefix' is a string, the prefix for the namespace.\n"
		"\n"
		"Returns 'True' if an XML Namespace with the given URI is contained in\n"
		"this XMLNamespaces list, 'False' otherwise.\n"
		"\n"
		""},
	 { "XMLNamespaces_hasNS", _wrap_XMLNamespaces_hasNS, METH_VARARGS, "\n"
		"XMLNamespaces_hasNS(XMLNamespaces self, string uri, string prefix) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether an XML\n"
		"Namespace with the given URI and prefix pair is contained in this\n"
		"XMLNamespaces list.\n"
		"\n"
		"Parameter 'uri' is a string, the URI for the namespace. Parameter\n"
		"'prefix' is a string, the prefix for the namespace.\n"
		"\n"
		"Returns 'True' if an XML Namespace with the given uri/prefix pair is\n"
		"contained in this XMLNamespaces list, 'False' otherwise.\n"
		"\n"
		""},
	 { "XMLNamespaces_swigregister", XMLNamespaces_swigregister, METH_O, NULL},
	 { "XMLNamespaces_swiginit", XMLNamespaces_swiginit, METH_VARARGS, NULL},
	 { "delete_XMLToken", _wrap_delete_XMLToken, METH_O, "delete_XMLToken(XMLToken self)"},
	 { "new_XMLToken", _wrap_new_XMLToken, METH_VARARGS, "\n"
		"XMLToken()\n"
		"XMLToken(XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces, unsigned int const line=0, unsigned int const column=0)\n"
		"XMLToken(XMLTriple triple, XMLAttributes attributes, unsigned int const line=0, unsigned int const column=0)\n"
		"XMLToken(XMLTriple triple, unsigned int const line=0, unsigned int const column=0)\n"
		"XMLToken(string chars, unsigned int const line=0, unsigned int const column=0)\n"
		"new_XMLToken(XMLToken orig) -> XMLToken\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLToken()\n"
		"\n"
		"Creates a new empty XMLToken object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLToken(XMLToken orig)\n"
		"\n"
		"Copy constructor; creates a copy of this XMLToken object.\n"
		"\n"
		"Parameter 'orig' is the XMLToken object to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLToken(  XMLTriple      triple , XMLAttributes  attributes\n"
		",  long    line   = 0 ,  long    column = 0 )\n"
		"\n"
		"Creates an XML start element with attributes.\n"
		"\n"
		"Parameter 'triple' is an XMLTriple object describing the start tag.\n"
		"\n"
		"Parameter 'attributes' is XMLAttributes, the attributes to set on the\n"
		"element to be created.\n"
		"\n"
		"Parameter 'line' is a long integer, the line number to associate with\n"
		"the token (default = 0).\n"
		"\n"
		"Parameter 'column' is a long integer, the column number to associate\n"
		"with the token (default = 0).\n"
		"\n"
		"The XML namespace component of this XMLToken object will be left\n"
		"empty. See the other variants of the XMLToken constructors for\n"
		"versions that take namespace arguments.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLToken(  XMLTriple    triple ,  long  line   = 0 ,  long\n"
		"column = 0 )\n"
		"\n"
		"Creates an XML end element.\n"
		"\n"
		"Parameter 'triple' is an XMLTriple object describing the end tag.\n"
		"\n"
		"Parameter 'line' is a long integer, the line number to associate with\n"
		"the token (default = 0).\n"
		"\n"
		"Parameter 'column' is a long integer, the column number to associate\n"
		"with the token (default = 0).\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLToken(  XMLTriple      triple , XMLAttributes  attributes\n"
		", XMLNamespaces  namespaces ,  long    line   = 0 ,  long    column =\n"
		"0 )\n"
		"\n"
		"Creates an XML start element with attributes and namespace\n"
		"declarations.\n"
		"\n"
		"Parameter 'triple' is an XMLTriple object describing the start tag.\n"
		"\n"
		"Parameter 'attributes' is XMLAttributes, the attributes to set on the\n"
		"element to be created.\n"
		"\n"
		"Parameter 'namespaces' is XMLNamespaces, the namespaces to set on the\n"
		"element to be created.\n"
		"\n"
		"Parameter 'line' is a long integer, the line number to associate with\n"
		"the token (default = 0).\n"
		"\n"
		"Parameter 'column' is a long integer, the column number to associate\n"
		"with the token (default = 0).\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLToken(  string  chars ,  long  line   = 0 ,  long  column\n"
		"= 0 )\n"
		"\n"
		"Creates a text object.\n"
		"\n"
		"Parameter 'chars' is a string, the text to be added to the XMLToken\n"
		"object.\n"
		"\n"
		"Parameter 'line' is a long integer, the line number to associate with\n"
		"the token (default = 0).\n"
		"\n"
		"Parameter 'column' is a long integer, the column number to associate\n"
		"with the token (default = 0).\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "XMLToken_clone", _wrap_XMLToken_clone, METH_O, "\n"
		"XMLToken_clone(XMLToken self) -> XMLToken\n"
		"\n"
		"Creates and returns a deep copy of this XMLToken object.\n"
		"\n"
		"Returns the (deep) copy of this XMLToken object.\n"
		"\n"
		""},
	 { "XMLToken_getAttributes", _wrap_XMLToken_getAttributes, METH_O, "\n"
		"XMLToken_getAttributes(XMLToken self) -> XMLAttributes\n"
		"\n"
		"Returns the attributes of the XML element represented by this token.\n"
		"\n"
		"Returns the attributes of this XML element, stored in an XMLAttributes\n"
		"object.\n"
		"\n"
		""},
	 { "XMLToken_setAttributes", _wrap_XMLToken_setAttributes, METH_VARARGS, "\n"
		"XMLToken_setAttributes(XMLToken self, XMLAttributes attributes) -> int\n"
		"\n"
		"Sets the attributes on the XML element represented by this token.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Parameter 'attributes' is an XMLAttributes object to be assigned to\n"
		"this XMLToken object, thereby setting the XML attributes associated\n"
		"with this token.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"Note: This function replaces any existing XMLAttributes object on this\n"
		"XMLToken object with the one given by 'attributes'.\n"
		"\n"
		""},
	 { "XMLToken_addAttr", _wrap_XMLToken_addAttr, METH_VARARGS, "\n"
		"XMLToken_addAttr(XMLToken self, string name, string value, string namespaceURI=\"\", string prefix=\"\") -> int\n"
		"XMLToken_addAttr(XMLToken self, XMLTriple triple, string value) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addAttr(  string name , string value , string namespaceURI =\n"
		"'' , string prefix = '')\n"
		"\n"
		"Adds an attribute to the XML element represented by this token.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Parameter 'name' is a string, the so-called 'local part' of the\n"
		"attribute name; that is, the attribute name without any namespace\n"
		"qualifier or prefix.\n"
		"\n"
		"Parameter 'value' is a string, the value assigned to the attribute.\n"
		"\n"
		"Parameter 'namespaceURI' is a string, the XML namespace URI of the\n"
		"attribute.\n"
		"\n"
		"Parameter 'prefix' is a string, the prefix for the XML namespace.\n"
		"\n"
		"Recall that in XML, the complete form of an attribute on an XML\n"
		"element is the following: <center> prefix:name='value' </center> The\n"
		"name part is the name of the attribute, the 'value' part is the value\n"
		"assigned to the attribute (and it is always a quoted string), and the\n"
		"prefix part is an optional XML namespace prefix.  Internally in\n"
		"libSBML, this data is stored in an XMLAttributes object associated\n"
		"with this XMLToken.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"Note: If an attribute with the same name and XML namespace URI already\n"
		"exists on this XMLToken object, then the previous value will be\n"
		"replaced with the new value provided to this method.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    addAttr( XMLTriple triple, string value)\n"
		"\n"
		"Adds an attribute to the XML element represented by this token.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Parameter 'triple' is an XMLTriple object defining the attribute, its\n"
		"value, and optionally its XML namespace (if any is provided).\n"
		"\n"
		"Parameter 'value' is a string, the value assigned to the attribute.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"Note: If an attribute with the same name and XML namespace URI already\n"
		"exists on this XMLToken object, then the previous value will be\n"
		"replaced with the new value provided to this method.\n"
		"\n"
		""},
	 { "XMLToken_removeAttr", _wrap_XMLToken_removeAttr, METH_VARARGS, "\n"
		"XMLToken_removeAttr(XMLToken self, int n) -> int\n"
		"XMLToken_removeAttr(XMLToken self, string name, string uri=\"\") -> int\n"
		"XMLToken_removeAttr(XMLToken self, XMLTriple triple) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeAttr(string name, string uri = '')\n"
		"\n"
		"Removes an attribute from the XML element represented by this token.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Parameter 'name' is a string, the name of the attribute to be removed.\n"
		"Parameter 'uri' is a string, the XML namespace URI of the attribute to\n"
		"be removed.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no\n"
		"attribute on this element with the given 'name' (and 'uri' if\n"
		"specified).\n"
		"\n"
		"See also hasAttr().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeAttr(int n)\n"
		"\n"
		"Removes the nth attribute from the XML element represented by this\n"
		"token.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Parameter 'n' is an integer the index of the resource to be deleted.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no\n"
		"attribute on this element at the given index 'n'.\n"
		"\n"
		"See also getAttrIndex(), getAttrIndex(), getAttributesLength().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeAttr(XMLTriple triple)\n"
		"\n"
		"Removes an attribute from the XML element represented by this token.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Parameter 'triple' is an XMLTriple describing the attribute to be\n"
		"removed.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no\n"
		"attribute on this element matching the properties of the given\n"
		"'triple'.\n"
		"\n"
		"See also hasAttr().\n"
		"\n"
		""},
	 { "XMLToken_clearAttributes", _wrap_XMLToken_clearAttributes, METH_O, "\n"
		"XMLToken_clearAttributes(XMLToken self) -> int\n"
		"\n"
		"Removes all attributes of this XMLToken object.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		""},
	 { "XMLToken_getAttrIndex", _wrap_XMLToken_getAttrIndex, METH_VARARGS, "\n"
		"XMLToken_getAttrIndex(XMLToken self, string name, string uri=\"\") -> int\n"
		"XMLToken_getAttrIndex(XMLToken self, XMLTriple triple) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getAttrIndex(string name, string uri='')\n"
		"\n"
		"Returns the index of the attribute with the given name and namespace\n"
		"URI.\n"
		"\n"
		"Parameter 'name' is a string, the name of the attribute. Parameter\n"
		"'uri' is a string, the namespace URI of the attribute.\n"
		"\n"
		"Returns the index of an attribute with the given local name and\n"
		"namespace URI, or -1 if it is not present on this token.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getAttrIndex(XMLTriple triple)\n"
		"\n"
		"Returns the index of the attribute defined by the given XMLTriple\n"
		"object.\n"
		"\n"
		"Parameter 'triple' is the XMLTriple object that defines the attribute\n"
		"whose index is being sought.\n"
		"\n"
		"Returns the index of an attribute with the given XMLTriple object, or\n"
		"-1 if no such attribute is present on this token.\n"
		"\n"
		""},
	 { "XMLToken_getAttributesLength", _wrap_XMLToken_getAttributesLength, METH_O, "\n"
		"XMLToken_getAttributesLength(XMLToken self) -> int\n"
		"\n"
		"Returns the number of attributes on this XMLToken object.\n"
		"\n"
		"Returns the number of attributes possessed by this token.\n"
		"\n"
		"See also hasAttr().\n"
		"\n"
		""},
	 { "XMLToken_getAttrName", _wrap_XMLToken_getAttrName, METH_VARARGS, "\n"
		"XMLToken_getAttrName(XMLToken self, int index) -> string\n"
		"\n"
		"Returns the name of the nth attribute in this token's list of\n"
		"attributes.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the attribute whose\n"
		"name is being sought.\n"
		"\n"
		"Returns the name of the attribute located at position 'n' in the list\n"
		"of attributes possessed by this XMLToken object.\n"
		"\n"
		"Note: If 'index' is out of range, this method will return an empty\n"
		"string.  XMLToken.hasAttr() can be used to test for an attribute's\n"
		"existence explicitly, and XMLToken.getAttributesLength() can be used\n"
		"to find out the number of attributes possessed by this token.\n"
		"\n"
		"See also hasAttr(), getAttributesLength().\n"
		"\n"
		""},
	 { "XMLToken_getAttrPrefix", _wrap_XMLToken_getAttrPrefix, METH_VARARGS, "\n"
		"XMLToken_getAttrPrefix(XMLToken self, int index) -> string\n"
		"\n"
		"Returns the prefix of the nth attribute in this token's list of\n"
		"attributes.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the attribute whose\n"
		"prefix is being sought.\n"
		"\n"
		"Returns the XML namespace prefix of the attribute located at position\n"
		"'n' in the list of attributes possessed by this XMLToken object.\n"
		"\n"
		"Note: If 'index' is out of range, this method will return an empty\n"
		"string.  XMLToken.hasAttr() can be used to test for an attribute's\n"
		"existence explicitly, and XMLToken.getAttributesLength() can be used\n"
		"to find out the number of attributes possessed by this token.\n"
		"\n"
		"See also hasAttr(), getAttributesLength().\n"
		"\n"
		""},
	 { "XMLToken_getAttrPrefixedName", _wrap_XMLToken_getAttrPrefixedName, METH_VARARGS, "\n"
		"XMLToken_getAttrPrefixedName(XMLToken self, int index) -> string\n"
		"\n"
		"Returns the prefixed name of the nth attribute in this token's list of\n"
		"attributes.\n"
		"\n"
		"In this context, prefixed name means the name of the attribute\n"
		"prefixed with the XML namespace prefix assigned to the attribute.\n"
		"This will be a string of the form prefix:name.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the attribute whose\n"
		"prefixed name is being sought.\n"
		"\n"
		"Returns the prefixed name of the attribute located at position 'n' in\n"
		"the list of attributes possessed by this XMLToken object.\n"
		"\n"
		"Note: If 'index' is out of range, this method will return an empty\n"
		"string.  XMLToken.hasAttr() can be used to test for an attribute's\n"
		"existence explicitly, and XMLToken.getAttributesLength() can be used\n"
		"to find out the number of attributes possessed by this token.\n"
		"\n"
		""},
	 { "XMLToken_getAttrURI", _wrap_XMLToken_getAttrURI, METH_VARARGS, "\n"
		"XMLToken_getAttrURI(XMLToken self, int index) -> string\n"
		"\n"
		"Returns the XML namespace URI of the nth attribute in this token's\n"
		"list of attributes.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the attribute whose\n"
		"namespace URI is being sought.\n"
		"\n"
		"Returns the XML namespace URI of the attribute located at position 'n'\n"
		"in the list of attributes possessed by this XMLToken object.\n"
		"\n"
		"Note: If 'index' is out of range, this method will return an empty\n"
		"string.  XMLToken.hasAttr() can be used to test for an attribute's\n"
		"existence explicitly, and XMLToken.getAttributesLength() can be used\n"
		"to find out the number of attributes possessed by this token.\n"
		"\n"
		""},
	 { "XMLToken_getAttrValue", _wrap_XMLToken_getAttrValue, METH_VARARGS, "\n"
		"XMLToken_getAttrValue(XMLToken self, int index) -> string\n"
		"XMLToken_getAttrValue(XMLToken self, string name, string uri=\"\") -> string\n"
		"XMLToken_getAttrValue(XMLToken self, XMLTriple triple) -> string\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getAttrValue(string name, string uri='')\n"
		"\n"
		"Returns the value of the attribute with a given name and XML namespace\n"
		"URI.\n"
		"\n"
		"Parameter 'name' is a string, the name of the attribute whose value is\n"
		"being sought.\n"
		"\n"
		"Parameter 'uri' is a string, the XML namespace URI of the attribute.\n"
		"\n"
		"Returns The value of the attribute, as a string.\n"
		"\n"
		"Note: If an attribute with the given 'name' and 'uri' does not exist\n"
		"on this token object, this method will return an empty string.\n"
		"XMLToken.hasAttr() can be used to test explicitly for the presence of\n"
		"an attribute with a given name and namespace.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getAttrValue(XMLTriple triple)\n"
		"\n"
		"Returns the value of the attribute specified by a given XMLTriple\n"
		"object.\n"
		"\n"
		"Parameter 'triple' is an XMLTriple describing the attribute whose\n"
		"value is being sought.\n"
		"\n"
		"Returns The value of the attribute, as a string.\n"
		"\n"
		"Note: If an attribute defined by the given 'triple' does not exist on\n"
		"this token object, this method will return an empty string.\n"
		"XMLToken.hasAttr() can be used to test explicitly for the existence of\n"
		"an attribute with the properties of a given triple.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getAttrValue(int index)\n"
		"\n"
		"Returns the value of the nth attribute in this token's list of\n"
		"attributes.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the attribute whose\n"
		"value is required.\n"
		"\n"
		"Returns the value of the attribute located at position 'n' in the list\n"
		"of attributes possessed by this XMLToken object.\n"
		"\n"
		"Note: If 'index' is out of range, this method will return an empty\n"
		"string.  XMLToken.hasAttr() can be used to test for an attribute's\n"
		"existence explicitly, and XMLToken.getAttributesLength() can be used\n"
		"to find out the number of attributes possessed by this token.\n"
		"\n"
		""},
	 { "XMLToken_hasAttr", _wrap_XMLToken_hasAttr, METH_VARARGS, "\n"
		"XMLToken_hasAttr(XMLToken self, int index) -> bool\n"
		"XMLToken_hasAttr(XMLToken self, string name, string uri=\"\") -> bool\n"
		"XMLToken_hasAttr(XMLToken self, XMLTriple triple) -> bool\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    hasAttr(string name, string uri='')\n"
		"\n"
		"Returns 'True' if an attribute with a given name and namespace URI\n"
		"exists.\n"
		"\n"
		"Parameter 'name' is a string, the name of the attribute being sought.\n"
		"\n"
		"Parameter 'uri' is a string, the XML namespace URI of the attribute\n"
		"being sought.\n"
		"\n"
		"Returns 'True' if an attribute with the given local name and namespace\n"
		"URI exists in the list of attributes on this token object, 'False'\n"
		"otherwise.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    hasAttr(XMLTriple triple)\n"
		"\n"
		"Returns 'True' if an attribute defined by a given XMLTriple object\n"
		"exists.\n"
		"\n"
		"Parameter 'triple' is an XMLTriple object describing the attribute\n"
		"being sought.\n"
		"\n"
		"Returns 'True' if an attribute matching the properties of the given\n"
		"XMLTriple object exists in the list of attributes on this token,\n"
		"'False' otherwise.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    hasAttr(int index)\n"
		"\n"
		"Returns 'True' if an attribute with the given index exists.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the attribute.\n"
		"\n"
		"Returns 'True' if this token object possesses an attribute with the\n"
		"given index, 'False' otherwise.\n"
		"\n"
		""},
	 { "XMLToken_isAttributesEmpty", _wrap_XMLToken_isAttributesEmpty, METH_O, "\n"
		"XMLToken_isAttributesEmpty(XMLToken self) -> bool\n"
		"\n"
		"Returns 'True' if this token has no attributes.\n"
		"\n"
		"Returns 'True' if the list of attributes on XMLToken object is empty,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "XMLToken_getNamespaces", _wrap_XMLToken_getNamespaces, METH_O, "\n"
		"XMLToken_getNamespaces(XMLToken self) -> XMLNamespaces\n"
		"\n"
		"Returns the XML namespaces declared for this token.\n"
		"\n"
		"Returns the XML namespace declarations for this XML element.\n"
		"\n"
		""},
	 { "XMLToken_setNamespaces", _wrap_XMLToken_setNamespaces, METH_VARARGS, "\n"
		"XMLToken_setNamespaces(XMLToken self, XMLNamespaces namespaces) -> int\n"
		"\n"
		"Sets the XML namespaces on this XML element.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Parameter 'namespaces' is the XMLNamespaces object to be assigned to\n"
		"this XMLToken object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"Note: This function replaces any existing XMLNamespaces object on this\n"
		"XMLToken object with the new one given by 'namespaces'.\n"
		"\n"
		""},
	 { "XMLToken_addNamespace", _wrap_XMLToken_addNamespace, METH_VARARGS, "\n"
		"XMLToken_addNamespace(XMLToken self, string uri, string prefix=\"\") -> int\n"
		"\n"
		"Appends an XML namespace declaration to this token.\n"
		"\n"
		"The namespace added will be defined by the given XML namespace URI and\n"
		"an optional prefix.  If this XMLToken object already possesses an XML\n"
		"namespace declaration with the given 'prefix', then the existing XML\n"
		"namespace URI will be overwritten by the new one given by 'uri'.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Parameter 'uri' is a string, the XML namespace URI for the namespace.\n"
		"\n"
		"Parameter 'prefix' is a string, the namespace prefix to use.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "XMLToken_removeNamespace", _wrap_XMLToken_removeNamespace, METH_VARARGS, "\n"
		"XMLToken_removeNamespace(XMLToken self, int index) -> int\n"
		"XMLToken_removeNamespace(XMLToken self, string prefix) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeNamespace(int index)\n"
		"\n"
		"Removes the nth XML namespace declaration.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the namespace to be\n"
		"removed. The position in this context refers to the position of the\n"
		"namespace in the XMLNamespaces object stored in this XMLToken object.\n"
		"Callers can use one of the getNamespace___() methods to find the index\n"
		"number of a given namespace.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"See also getNamespaceIndex(), getNamespaceIndexByPrefix(),\n"
		"getNamespacesLength().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeNamespace(string prefix)\n"
		"\n"
		"Removes an XML namespace declaration having a given prefix.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Parameter 'prefix' is a string, the prefix of the namespace to be\n"
		"removed.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no\n"
		"namespace with the given 'prefix' on this element.\n"
		"\n"
		"See also getNamespaceIndexByPrefix().\n"
		"\n"
		""},
	 { "XMLToken_clearNamespaces", _wrap_XMLToken_clearNamespaces, METH_O, "\n"
		"XMLToken_clearNamespaces(XMLToken self) -> int\n"
		"\n"
		"Removes all XML namespace declarations from this token.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "XMLToken_getNamespaceIndex", _wrap_XMLToken_getNamespaceIndex, METH_VARARGS, "\n"
		"XMLToken_getNamespaceIndex(XMLToken self, string uri) -> int\n"
		"\n"
		"Returns the index of an XML namespace declaration based on its URI.\n"
		"\n"
		"Parameter 'uri' is a string, the XML namespace URI of the sought-after\n"
		"namespace.\n"
		"\n"
		"Returns the index of the given declaration, or -1 if no such namespace\n"
		"URI is present on this XMLToken object.\n"
		"\n"
		""},
	 { "XMLToken_getNamespaceIndexByPrefix", _wrap_XMLToken_getNamespaceIndexByPrefix, METH_VARARGS, "\n"
		"XMLToken_getNamespaceIndexByPrefix(XMLToken self, string prefix) -> int\n"
		"\n"
		"Returns the index of an XML namespace declaration based on its prefix.\n"
		"\n"
		"Parameter 'prefix' is a string, the prefix of the sought-after XML\n"
		"namespace.\n"
		"\n"
		"Returns the index of the given declaration, or -1 if no such namespace\n"
		"URI is present on this XMLToken object.\n"
		"\n"
		""},
	 { "XMLToken_getNamespacesLength", _wrap_XMLToken_getNamespacesLength, METH_O, "\n"
		"XMLToken_getNamespacesLength(XMLToken self) -> int\n"
		"\n"
		"Returns the number of XML namespaces declared on this token.\n"
		"\n"
		"Returns the number of XML namespaces stored in the XMLNamespaces\n"
		"object of this XMLToken object.\n"
		"\n"
		""},
	 { "XMLToken_getNamespacePrefix", _wrap_XMLToken_getNamespacePrefix, METH_VARARGS, "\n"
		"XMLToken_getNamespacePrefix(XMLToken self, int index) -> string\n"
		"XMLToken_getNamespacePrefix(XMLToken self, string uri) -> string\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getNamespacePrefix(int index)\n"
		"\n"
		"Returns the prefix of the nth XML namespace declaration.\n"
		"\n"
		"Parameter 'index' is an integer, position of the required prefix.\n"
		"\n"
		"Returns the prefix of an XML namespace declaration in the\n"
		"XMLNamespaces (by position).\n"
		"\n"
		"Note: If 'index' is out of range, this method will return an empty\n"
		"string.  XMLToken.getNamespacesLength() can be used to find out how\n"
		"many namespaces are defined on this XMLToken object.\n"
		"\n"
		"See also getNamespacesLength().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getNamespacePrefix(string uri)\n"
		"\n"
		"Returns the prefix associated with a given XML namespace URI on this\n"
		"token.\n"
		"\n"
		"Parameter 'uri' is a string, the URI of the namespace whose prefix is\n"
		"being sought.\n"
		"\n"
		"Returns the prefix of an XML namespace declaration on this XMLToken\n"
		"object.\n"
		"\n"
		"Note: If there is no XML namespace with the given 'uri' declared on\n"
		"this XMLToken object, this method will return an empty string.\n"
		"\n"
		""},
	 { "XMLToken_getNamespaceURI", _wrap_XMLToken_getNamespaceURI, METH_VARARGS, "\n"
		"XMLToken_getNamespaceURI(XMLToken self, int index) -> string\n"
		"XMLToken_getNamespaceURI(XMLToken self, string prefix=\"\") -> string\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getNamespaceURI(string prefix = '')\n"
		"\n"
		"Returns the URI of an XML namespace with a given prefix.\n"
		"\n"
		"Parameter 'prefix' is a string, the prefix of the sought-after XML\n"
		"namespace URI.\n"
		"\n"
		"Returns the URI of an XML namespace declaration given its prefix.\n"
		"\n"
		"Note: If there is no XML namespace with the given 'prefix' stored in\n"
		"the XMLNamespaces object of this XMLToken object, this method will\n"
		"return an empty string.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getNamespaceURI(int index)\n"
		"\n"
		"Returns the URI of the nth XML namespace declared on this token.\n"
		"\n"
		"Parameter 'index' is an integer, the position of the sought-after XML\n"
		"namespace URI.\n"
		"\n"
		"Returns the URI of the nth XML namespace stored in the XMLNamespaces\n"
		"object in this XMLToken object.\n"
		"\n"
		"Note: If 'index' is out of range, this method will return an empty\n"
		"string.\n"
		"\n"
		"See also getNamespacesLength().\n"
		"\n"
		""},
	 { "XMLToken_isNamespacesEmpty", _wrap_XMLToken_isNamespacesEmpty, METH_O, "\n"
		"XMLToken_isNamespacesEmpty(XMLToken self) -> bool\n"
		"\n"
		"Returns 'True' if there are no namespaces declared on this token.\n"
		"\n"
		"Returns 'True' if the XMLNamespaces object stored in this XMLToken\n"
		"token is empty, 'False' otherwise.\n"
		"\n"
		""},
	 { "XMLToken_hasNamespaceURI", _wrap_XMLToken_hasNamespaceURI, METH_VARARGS, "\n"
		"XMLToken_hasNamespaceURI(XMLToken self, string uri) -> bool\n"
		"\n"
		"Returns 'True' if this token has an XML namespace with a given URI.\n"
		"\n"
		"Parameter 'uri' is a string, the URI of the XML namespace.\n"
		"\n"
		"Returns 'True' if an XML namespace with the given URI is contained in\n"
		"the XMLNamespaces object of this XMLToken object, 'False' otherwise.\n"
		"\n"
		""},
	 { "XMLToken_hasNamespacePrefix", _wrap_XMLToken_hasNamespacePrefix, METH_VARARGS, "\n"
		"XMLToken_hasNamespacePrefix(XMLToken self, string prefix) -> bool\n"
		"\n"
		"Returns 'True' if this token has an XML namespace with a given prefix.\n"
		"\n"
		"Parameter 'prefix' is a string, the prefix for the XML namespace.\n"
		"\n"
		"Returns 'True' if an XML Namespace with the given URI is contained in\n"
		"the XMLNamespaces of this XMLToken, 'False' otherwise.\n"
		"\n"
		""},
	 { "XMLToken_hasNamespaceNS", _wrap_XMLToken_hasNamespaceNS, METH_VARARGS, "\n"
		"XMLToken_hasNamespaceNS(XMLToken self, string uri, string prefix) -> bool\n"
		"\n"
		"Returns 'True' if this token has an XML namespace with a given prefix\n"
		"and URI combination.\n"
		"\n"
		"Parameter 'uri' is a string, the URI for the namespace. Parameter\n"
		"'prefix' is a string, the prefix for the namespace.\n"
		"\n"
		"Returns 'True' if an XML namespace with the given URI/prefix pair is\n"
		"contained in the XMLNamespaces object of this XMLToken object, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "XMLToken_setTriple", _wrap_XMLToken_setTriple, METH_VARARGS, "\n"
		"XMLToken_setTriple(XMLToken self, XMLTriple triple) -> int\n"
		"\n"
		"Sets the name, namespace prefix and namespace URI of this token.\n"
		"\n"
		"This operation only makes sense for XML start elements.  This method\n"
		"will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is\n"
		"not an XML start element.\n"
		"\n"
		"Parameter 'triple' is the new XMLTriple to use for this XMLToken\n"
		"object.  If this XMLToken already had an XMLTriple object stored\n"
		"within it, that object will be replaced.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "XMLToken_getName", _wrap_XMLToken_getName, METH_O, "\n"
		"XMLToken_getName(XMLToken self) -> string\n"
		"\n"
		"Returns the (unqualified) name of token.\n"
		"\n"
		"Returns the (unqualified) name of token.\n"
		"\n"
		""},
	 { "XMLToken_getPrefix", _wrap_XMLToken_getPrefix, METH_O, "\n"
		"XMLToken_getPrefix(XMLToken self) -> string\n"
		"\n"
		"Returns the XML namespace prefix of token.\n"
		"\n"
		"Returns the XML namespace prefix of token.\n"
		"\n"
		"Note: If no XML namespace prefix has been assigned to this token, this\n"
		"method will return an empty string.\n"
		"\n"
		""},
	 { "XMLToken_getURI", _wrap_XMLToken_getURI, METH_O, "\n"
		"XMLToken_getURI(XMLToken self) -> string\n"
		"\n"
		"Returns the XML namespace URI of token.\n"
		"\n"
		"Returns the XML namespace URI of token.\n"
		"\n"
		""},
	 { "XMLToken_getCharacters", _wrap_XMLToken_getCharacters, METH_O, "\n"
		"XMLToken_getCharacters(XMLToken self) -> string\n"
		"\n"
		"Returns the character text of token.\n"
		"\n"
		"Returns the characters of this XML token.  If this token is not a text\n"
		"token (i.e., it's an XML element and not character content), then this\n"
		"will return an empty string.\n"
		"\n"
		"See also isText(), isElement().\n"
		"\n"
		""},
	 { "XMLToken_setCharacters", _wrap_XMLToken_setCharacters, METH_VARARGS, "\n"
		"XMLToken_setCharacters(XMLToken self, string chars) -> int\n"
		"\n"
		"Sets the characters for this XMLToken\n"
		"\n"
		"This method only makes sense for XMLToken objects that contains text.\n"
		"If this method is called on a token that represents an XML start or\n"
		"end tag, it will return the code LIBSBML_OPERATION_FAILED.\n"
		"\n"
		"Parameter 'chars' is string, characters to append to the text of this\n"
		"token.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also isText(), isElement().\n"
		"\n"
		""},
	 { "XMLToken_append", _wrap_XMLToken_append, METH_VARARGS, "\n"
		"XMLToken_append(XMLToken self, string chars) -> int\n"
		"\n"
		"Appends characters to the text content of token.\n"
		"\n"
		"This method only makes sense for XMLToken objects that contains text.\n"
		"If this method is called on a token that represents an XML start or\n"
		"end tag, it will return the code LIBSBML_OPERATION_FAILED.\n"
		"\n"
		"Parameter 'chars' is string, characters to append to the text of this\n"
		"token.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also isText(), isElement().\n"
		"\n"
		""},
	 { "XMLToken_getColumn", _wrap_XMLToken_getColumn, METH_O, "\n"
		"XMLToken_getColumn(XMLToken self) -> unsigned int\n"
		"\n"
		"Returns the column number at which this token occurs in the input.\n"
		"\n"
		"Returns the column at which this XMLToken occurred.\n"
		"\n"
		""},
	 { "XMLToken_getLine", _wrap_XMLToken_getLine, METH_O, "\n"
		"XMLToken_getLine(XMLToken self) -> unsigned int\n"
		"\n"
		"Returns the line number at which this token occurs in the input.\n"
		"\n"
		"Returns the line at which this XMLToken occurred.\n"
		"\n"
		""},
	 { "XMLToken_isElement", _wrap_XMLToken_isElement, METH_O, "\n"
		"XMLToken_isElement(XMLToken self) -> bool\n"
		"\n"
		"Returns 'True' if this token represents an XML element.\n"
		"\n"
		"This generic predicate returns 'True' if the element is either a start\n"
		"or end tag, and 'False' if it's a text object.  The related methods\n"
		"XMLToken:isStart(), XMLToken.isEnd() and XMLToken.isText() are more\n"
		"specific predicates.\n"
		"\n"
		"Returns 'True' if this XMLToken object represents an XML element,\n"
		"'False' otherwise.\n"
		"\n"
		"See also isStart(), isEnd(), isText().\n"
		"\n"
		""},
	 { "XMLToken_isEnd", _wrap_XMLToken_isEnd, METH_O, "\n"
		"XMLToken_isEnd(XMLToken self) -> bool\n"
		"\n"
		"Returns 'True' if this token represents an XML end element.\n"
		"\n"
		"Returns 'True' if this XMLToken object represents an XML end element,\n"
		"'False' otherwise.\n"
		"\n"
		"See also isStart(), isElement(), isText().\n"
		"\n"
		""},
	 { "XMLToken_isEndFor", _wrap_XMLToken_isEndFor, METH_VARARGS, "\n"
		"XMLToken_isEndFor(XMLToken self, XMLToken element) -> bool\n"
		"\n"
		"Returns 'True' if this token represents an XML end element for a\n"
		"particular start element.\n"
		"\n"
		"Parameter 'element' is XMLToken, the element with which the current\n"
		"object should be compared to determined whether the current object is\n"
		"a start element for the given one.\n"
		"\n"
		"Returns 'True' if this XMLToken object represents an XML end tag for\n"
		"the start tag given by 'element', 'False' otherwise.\n"
		"\n"
		"See also isElement(), isStart(), isEnd(), isText().\n"
		"\n"
		""},
	 { "XMLToken_isEOF", _wrap_XMLToken_isEOF, METH_O, "\n"
		"XMLToken_isEOF(XMLToken self) -> bool\n"
		"\n"
		"Returns 'True' if this token is an end of file marker.\n"
		"\n"
		"Returns 'True' if this XMLToken object represents the end of the\n"
		"input, 'False' otherwise.\n"
		"\n"
		"See also setEOF().\n"
		"\n"
		""},
	 { "XMLToken_isStart", _wrap_XMLToken_isStart, METH_O, "\n"
		"XMLToken_isStart(XMLToken self) -> bool\n"
		"\n"
		"Returns 'True' if this token represents an XML start element.\n"
		"\n"
		"Returns 'True' if this XMLToken is an XML start element, 'False'\n"
		"otherwise.\n"
		"\n"
		"See also isElement(), isEnd(), isText().\n"
		"\n"
		""},
	 { "XMLToken_isText", _wrap_XMLToken_isText, METH_O, "\n"
		"XMLToken_isText(XMLToken self) -> bool\n"
		"\n"
		"Returns 'True' if this token represents an XML text element.\n"
		"\n"
		"Returns 'True' if this XMLToken is an XML text element, 'False'\n"
		"otherwise.\n"
		"\n"
		"See also isElement(), isStart(), isEnd().\n"
		"\n"
		""},
	 { "XMLToken_setEnd", _wrap_XMLToken_setEnd, METH_O, "\n"
		"XMLToken_setEnd(XMLToken self) -> int\n"
		"\n"
		"Declares that this token represents an XML element end tag.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also isStart(), isEnd().\n"
		"\n"
		""},
	 { "XMLToken_setEOF", _wrap_XMLToken_setEOF, METH_O, "\n"
		"XMLToken_setEOF(XMLToken self) -> int\n"
		"\n"
		"Declares that this token is an end-of-file/input marker.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also isEOF().\n"
		"\n"
		""},
	 { "XMLToken_unsetEnd", _wrap_XMLToken_unsetEnd, METH_O, "\n"
		"XMLToken_unsetEnd(XMLToken self) -> int\n"
		"\n"
		"Declares that this token no longer represents an XML start/end\n"
		"element.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "XMLToken_toString", _wrap_XMLToken_toString, METH_O, "\n"
		"XMLToken_toString(XMLToken self) -> string\n"
		"\n"
		"Prints a string representation of the underlying token stream.\n"
		"\n"
		"This method is intended for debugging purposes.\n"
		"\n"
		"Returns a text string representing this XMLToken object.\n"
		"\n"
		""},
	 { "XMLToken_swigregister", XMLToken_swigregister, METH_O, NULL},
	 { "XMLToken_swiginit", XMLToken_swiginit, METH_VARARGS, NULL},
	 { "delete_XMLNode", _wrap_delete_XMLNode, METH_O, "delete_XMLNode(XMLNode self)"},
	 { "new_XMLNode", _wrap_new_XMLNode, METH_VARARGS, "\n"
		"XMLNode()\n"
		"XMLNode(XMLToken token)\n"
		"XMLNode(XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces, unsigned int const line=0, unsigned int const column=0)\n"
		"XMLNode(XMLTriple triple, XMLAttributes attributes, unsigned int const line=0, unsigned int const column=0)\n"
		"XMLNode(XMLTriple triple, unsigned int const line=0, unsigned int const column=0)\n"
		"XMLNode(string chars, unsigned int const line=0, unsigned int const column=0)\n"
		"XMLNode(XMLInputStream stream)\n"
		"new_XMLNode(XMLNode orig) -> XMLNode\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLNode(XMLToken token)\n"
		"\n"
		"Creates a new XMLNode by copying an XMLToken object.\n"
		"\n"
		"Parameter 'token' is XMLToken to be copied to XMLNode.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLNode(  XMLTriple     triple , XMLAttributes attributes ,\n"
		"XMLNamespaces namespaces ,  long   line   = 0 ,  long   column = 0 )\n"
		"\n"
		"Creates a new start element XMLNode with the given set of attributes\n"
		"and namespace declarations.\n"
		"\n"
		"Parameter 'triple' is XMLTriple. Parameter 'attributes' is\n"
		"XMLAttributes, the attributes to set. Parameter 'namespaces' is\n"
		"XMLNamespaces, the namespaces to set. Parameter 'line' is a long\n"
		"integer, the line number (default = 0). Parameter 'column' is a long\n"
		"integer, the column number (default = 0).\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLNode(XMLNode orig)\n"
		"\n"
		"Copy constructor; creates a copy of this XMLNode.\n"
		"\n"
		"Parameter 'orig' is the XMLNode instance to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLNode()\n"
		"\n"
		"Creates a new empty XMLNode with no children.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLNode(  XMLTriple      triple , XMLAttributes  attributes ,\n"
		"long    line   = 0 ,  long    column = 0 )\n"
		"\n"
		"Creates a start element XMLNode with the given set of attributes.\n"
		"\n"
		"Parameter 'triple' is XMLTriple. Parameter 'attributes' is\n"
		"XMLAttributes, the attributes to set. Parameter 'line' is a long\n"
		"integer, the line number (default = 0). Parameter 'column' is a long\n"
		"integer, the column number (default = 0).\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLNode(  XMLTriple    triple ,  long  line   = 0 ,  long\n"
		"column = 0 )\n"
		"\n"
		"Creates an end element XMLNode.\n"
		"\n"
		"Parameter 'triple' is XMLTriple. Parameter 'line' is a long integer,\n"
		"the line number (default = 0). Parameter 'column' is a long integer,\n"
		"the column number (default = 0).\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLNode(  string  chars ,  long  line   = 0 ,  long  column =\n"
		"0 )\n"
		"\n"
		"Creates a text XMLNode.\n"
		"\n"
		"Parameter 'chars' is a string, the text to be added to the XMLToken.\n"
		"Parameter 'line' is a long integer, the line number (default = 0).\n"
		"Parameter 'column' is a long integer, the column number (default = 0).\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "XMLNode_clone", _wrap_XMLNode_clone, METH_O, "\n"
		"XMLNode_clone(XMLNode self) -> XMLNode\n"
		"\n"
		"Creates and returns a deep copy of this XMLNode object.\n"
		"\n"
		"Returns the (deep) copy of this XMLNode object.\n"
		"\n"
		""},
	 { "XMLNode_addChild", _wrap_XMLNode_addChild, METH_VARARGS, "\n"
		"XMLNode_addChild(XMLNode self, XMLNode node) -> int\n"
		"\n"
		"Adds a copy of 'node' as a child of this XMLNode.\n"
		"\n"
		"The given 'node' is added at the end of the list of children.\n"
		"\n"
		"Parameter 'node' is the XMLNode to be added as child.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_XML_OPERATION\n"
		"\n"
		"Note: The given node is added at the end of the children list.\n"
		"\n"
		""},
	 { "XMLNode_insertChild", _wrap_XMLNode_insertChild, METH_VARARGS, "\n"
		"XMLNode_insertChild(XMLNode self, unsigned int n, XMLNode node) -> XMLNode\n"
		"\n"
		"Inserts a copy of the given node as the nth child of this XMLNode.\n"
		"\n"
		"If the given index 'n' is out of range for this XMLNode instance, the\n"
		"'node' is added at the end of the list of children.  Even in that\n"
		"situation, this method does not throw an error.\n"
		"\n"
		"Parameter 'n' is an integer, the index at which the given node is\n"
		"inserted. Parameter 'node' is an XMLNode to be inserted as nth child.\n"
		"\n"
		"Returns a reference to the newly-inserted child 'node'.\n"
		"\n"
		""},
	 { "XMLNode_removeChild", _wrap_XMLNode_removeChild, METH_VARARGS, "\n"
		"XMLNode_removeChild(XMLNode self, unsigned int n) -> XMLNode\n"
		"\n"
		"Removes the nth child of this XMLNode and returns the removed node.\n"
		"\n"
		"It is important to keep in mind that a given XMLNode may have more\n"
		"than one child.  Calling this method erases all existing references to\n"
		"child nodes after the given position 'n'.  If the index 'n' is greater\n"
		"than the number of child nodes in this XMLNode, this method takes no\n"
		"action (and returns 'None).'\n"
		"\n"
		"Parameter 'n' is an integer, the index of the node to be removed.\n"
		"\n"
		"Returns the removed child, or 'None' if 'n' is greater than the number\n"
		"of children in this node.\n"
		"\n"
		"Note: The caller owns the returned node and is responsible for\n"
		"deleting it.\n"
		"\n"
		""},
	 { "XMLNode_removeChildren", _wrap_XMLNode_removeChildren, METH_O, "\n"
		"XMLNode_removeChildren(XMLNode self) -> int\n"
		"\n"
		"Removes all children from this node. Returns integer value indicating\n"
		"success/failure of the function.   The possible values returned by\n"
		"this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "XMLNode_getChild", _wrap_XMLNode_getChild, METH_VARARGS, "\n"
		"XMLNode_getChild(XMLNode self, unsigned int n) -> XMLNode\n"
		"XMLNode_getChild(XMLNode self, unsigned int n) -> XMLNode\n"
		"XMLNode_getChild(XMLNode self, string name) -> XMLNode\n"
		"XMLNode_getChild(XMLNode self, string name) -> XMLNode\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getChild(long n)\n"
		"\n"
		"Returns the  nth child of this XMLNode.\n"
		"\n"
		"If the index 'n' is greater than the number of child nodes, this\n"
		"method returns an empty node.\n"
		"\n"
		"Parameter 'n' is a long integereger, the index of the node to return.\n"
		"\n"
		"Returns the nth child of this XMLNode.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getChild(string  name)\n"
		"\n"
		"Returns the first child of this XMLNode with the corresponding name.\n"
		"\n"
		"If no child with corrsponding name can be found, this method returns\n"
		"an empty node.\n"
		"\n"
		"Parameter 'name' is the name of the node to return.\n"
		"\n"
		"Returns the first child of this XMLNode with given name.\n"
		"\n"
		""},
	 { "XMLNode_getIndex", _wrap_XMLNode_getIndex, METH_VARARGS, "\n"
		"XMLNode_getIndex(XMLNode self, string name) -> int\n"
		"\n"
		"Return the index of the first child of this XMLNode with the given\n"
		"name.\n"
		"\n"
		"Parameter 'name' is a string, the name of the child for which the\n"
		"index is required.\n"
		"\n"
		"Returns the index of the first child of this XMLNode with the given\n"
		"name, or '-1' if not present.\n"
		"\n"
		""},
	 { "XMLNode_hasChild", _wrap_XMLNode_hasChild, METH_VARARGS, "\n"
		"XMLNode_hasChild(XMLNode self, string name) -> bool\n"
		"\n"
		"Return a boolean indicating whether this XMLNode has a child with the\n"
		"given name.\n"
		"\n"
		"Parameter 'name' is a string, the name of the child to be checked.\n"
		"\n"
		"Returns boolean indicating whether this XMLNode has a child with the\n"
		"given name.\n"
		"\n"
		""},
	 { "XMLNode_equals", _wrap_XMLNode_equals, METH_VARARGS, "\n"
		"XMLNode_equals(XMLNode self, XMLNode other, bool ignoreURI=False, bool ignoreAttributeValues=False) -> bool\n"
		"\n"
		"Compare this XMLNode against another XMLNode returning true if both\n"
		"nodes represent the same XML tree, or false otherwise.\n"
		"\n"
		"Parameter 'other' is another XMLNode to compare against.\n"
		"\n"
		"Parameter 'ignoreURI' is whether to ignore the namespace URI when\n"
		"doing the comparison.\n"
		"\n"
		"Parameter 'ignoreAttributeValues' is whetehr to ignore attribute\n"
		"values when  doing the comparison.\n"
		"\n"
		"Returns boolean indicating whether this XMLNode represents the same\n"
		"XML tree as another.\n"
		"\n"
		""},
	 { "XMLNode_getNumChildren", _wrap_XMLNode_getNumChildren, METH_O, "\n"
		"XMLNode_getNumChildren(XMLNode self) -> unsigned int\n"
		"\n"
		"Returns the number of children for this XMLNode.\n"
		"\n"
		"Returns the number of children for this XMLNode.\n"
		"\n"
		""},
	 { "XMLNode_writeToStream", _wrap_XMLNode_writeToStream, METH_VARARGS, "\n"
		"XMLNode_writeToStream(XMLNode self, XMLOutputStream stream)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "XMLNode_toXMLString", _wrap_XMLNode_toXMLString, METH_O, "\n"
		"XMLNode_toXMLString(XMLNode self) -> string\n"
		"\n"
		"Returns a string representation of this XMLNode.\n"
		"\n"
		"Returns a string derived from this XMLNode.\n"
		"\n"
		""},
	 { "XMLNode_convertXMLNodeToString", _wrap_XMLNode_convertXMLNodeToString, METH_O, "\n"
		"XMLNode_convertXMLNodeToString(XMLNode node) -> string\n"
		"\n"
		"Returns a string representation of a given XMLNode.\n"
		"\n"
		"Parameter 'node' is the XMLNode to be represented as a string.\n"
		"\n"
		"Returns a string-form representation of 'node'.\n"
		"\n"
		""},
	 { "XMLNode_convertStringToXMLNode", _wrap_XMLNode_convertStringToXMLNode, METH_VARARGS, "\n"
		"XMLNode_convertStringToXMLNode(string xmlstr, XMLNamespaces xmlns=None) -> XMLNode\n"
		"\n"
		"Returns an XMLNode which is derived from a string containing XML\n"
		"content.\n"
		"\n"
		"The XML namespace must be defined using argument 'xmlns' if the\n"
		"corresponding XML namespace attribute is not part of the string of the\n"
		"first argument.\n"
		"\n"
		"Parameter 'xmlstr' is string to be converted to a XML node. Parameter\n"
		"'xmlns' is XMLNamespaces the namespaces to set (default value is\n"
		"'None).'\n"
		"\n"
		"Note: The caller owns the returned XMLNode and is reponsible for\n"
		"deleting it.  The returned XMLNode object is a dummy root (container)\n"
		"XMLNode if the top-level element in the given XML string is NOT\n"
		"<html>, <body>, <annotation>, or <notes>.  In the dummy root node,\n"
		"each top-level element in the given XML string is contained as a child\n"
		"XMLNode. XMLToken.isEOF() can be used to identify if the returned\n"
		"XMLNode object is a dummy node.\n"
		"\n"
		"Returns a XMLNode which is converted from string 'xmlstr'.  If the\n"
		"conversion failed, this method returns 'None.'\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "XMLNode_swigregister", XMLNode_swigregister, METH_O, NULL},
	 { "XMLNode_swiginit", XMLNode_swiginit, METH_VARARGS, NULL},
	 { "new_XMLTriple", _wrap_new_XMLTriple, METH_VARARGS, "\n"
		"XMLTriple()\n"
		"XMLTriple(string name, string uri, string prefix)\n"
		"XMLTriple(string triplet, char const sepchar=' ')\n"
		"new_XMLTriple(XMLTriple orig) -> XMLTriple\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLTriple(  string  name , string  uri , string  prefix )\n"
		"\n"
		"Creates a new XMLTriple object with a given 'name', 'uri' and and\n"
		"'prefix'.\n"
		"\n"
		"Parameter 'name' is a string, the name for the entity represented by\n"
		"this object. Parameter 'uri' is a string, the XML namespace URI\n"
		"associated with the prefix. Parameter 'prefix' is a string, the XML\n"
		"namespace prefix for this triple.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLTriple(string triplet,  char sepchar = ' ')\n"
		"\n"
		"Creates an XMLTriple object by splitting a given string at a given\n"
		"separator character.\n"
		"\n"
		"The 'triplet' in this case is a string that may be in one of the\n"
		"following three possible formats: <ol>\n"
		"\n"
		"* name * URIxname* URIxnamexprefix</ol>\n"
		"\n"
		"where x represents the separator character, 'sepchar'.\n"
		"\n"
		"Parameter 'triplet' is a string representing the triplet as shown\n"
		"above. Parameter 'sepchar' is a character, the sepchar used in the\n"
		"triplet.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLTriple()\n"
		"\n"
		"Creates a new, empty XMLTriple object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLTriple(XMLTriple orig)\n"
		"\n"
		"Copy constructor; creates a copy of this XMLTriple object.\n"
		"\n"
		"Parameter 'orig' is the XMLTriple object to copy.\n"
		"\n"
		""},
	 { "delete_XMLTriple", _wrap_delete_XMLTriple, METH_O, "delete_XMLTriple(XMLTriple self)"},
	 { "XMLTriple_clone", _wrap_XMLTriple_clone, METH_O, "\n"
		"XMLTriple_clone(XMLTriple self) -> XMLTriple\n"
		"\n"
		"Creates and returns a deep copy of this XMLTriple object.\n"
		"\n"
		"Returns the (deep) copy of this XMLTriple object.\n"
		"\n"
		""},
	 { "XMLTriple_getName", _wrap_XMLTriple_getName, METH_O, "\n"
		"XMLTriple_getName(XMLTriple self) -> string\n"
		"\n"
		"Returns the name portion of this XMLTriple object.\n"
		"\n"
		"Returns a string, the name portion of this XMLTriple object.\n"
		"\n"
		""},
	 { "XMLTriple_getPrefix", _wrap_XMLTriple_getPrefix, METH_O, "\n"
		"XMLTriple_getPrefix(XMLTriple self) -> string\n"
		"\n"
		"Returns the prefix portion of this XMLTriple object.\n"
		"\n"
		"Returns a string, the prefix portion of this XMLTriple object.\n"
		"\n"
		""},
	 { "XMLTriple_getURI", _wrap_XMLTriple_getURI, METH_O, "\n"
		"XMLTriple_getURI(XMLTriple self) -> string\n"
		"\n"
		"Returns the URI portion of this XMLTriple object.\n"
		"\n"
		"Returns URI a string, the URI portion of this XMLTriple object.\n"
		"\n"
		""},
	 { "XMLTriple_getPrefixedName", _wrap_XMLTriple_getPrefixedName, METH_O, "\n"
		"XMLTriple_getPrefixedName(XMLTriple self) -> string\n"
		"\n"
		"Returns the prefixed name from this XMLTriple.\n"
		"\n"
		"Returns a string, the prefixed name from this XMLTriple.  This is\n"
		"constructed by concatenating the prefix stored in this XMLTriple\n"
		"object, followed by a colon character ':', followed by the name stored\n"
		"in this XMLTriple object.\n"
		"\n"
		""},
	 { "XMLTriple_isEmpty", _wrap_XMLTriple_isEmpty, METH_O, "\n"
		"XMLTriple_isEmpty(XMLTriple self) -> bool\n"
		"\n"
		"Returns 'True' if this XMLTriple object is empty.\n"
		"\n"
		"Returns 'True' if this XMLTriple is empty, 'False' otherwise.\n"
		"\n"
		""},
	 { "XMLTriple_swigregister", XMLTriple_swigregister, METH_O, NULL},
	 { "XMLTriple_swiginit", XMLTriple_swiginit, METH_VARARGS, NULL},
	 { "new_XMLOutputStream", _wrap_new_XMLOutputStream, METH_VARARGS, "\n"
		"XMLOutputStream(ostream stream, string encoding=\"UTF-8\", bool writeXMLDecl=True, string programName=\"\", string programVersion=\"\")\n"
		"\n"
		"Creates a new XMLOutputStream that wraps the given @p stream.\n"
		"\n"
		"The functionality associated with the @p programName and @p\n"
		"programVersion arguments concerns an optional comment that libSBML can\n"
		"write at the beginning of the output stream.  The comment is intended\n"
		"for human readers of the XML file, and has the following form:\n"
		"@verbatim\n"
		"<!-- Created by <program name> version <program version>\n"
		"on yyyy-MM-dd HH:mm with libSBML version <libsbml version>. -->\n"
		"@endverbatim\n"
		"\n"
		"This program information comment is a separate item from the XML\n"
		"declaration that this method can also write to this output stream.  The\n"
		"comment is also not mandated by any SBML specification.  This libSBML\n"
		"functionality is provided for the convenience of calling programs, and to\n"
		"help humans trace the origin of SBML files.\n"
		"\n"
		"LibSBML tries to produce human-readable XML output by automatically\n"
		"indenting the bodies of elements.  Callers can manually control\n"
		"indentation further by using the XMLOutputStream::upIndent()\n"
		"and XMLOutputStream::downIndent() methods to increase and\n"
		"decrease, respectively, the current level of indentation in the\n"
		"XML output.\n"
		"\n"
		"@param stream the input stream to wrap.\n"
		"\n"
		"@param encoding the XML encoding to declare in the output. This value should\n"
		"be <code>&quot;UTF-8&quot;</code> for SBML documents.  The default value is\n"
		"<code>&quot;UTF-8&quot;</code> if no value is supplied for this parameter.\n"
		"\n"
		"@param writeXMLDecl whether to write a standard XML declaration at\n"
		"the beginning of the content written on @p stream.  The default is\n"
		"@c true.\n"
		"\n"
		"@param programName an optional program name to write as a comment\n"
		"in the output stream.\n"
		"\n"
		"@param programVersion an optional version identification string to write\n"
		"as a comment in the output stream.\n"
		"\n"
		"@htmlinclude warn-default-args-in-docs.html\n"
		"\n"
		""},
	 { "delete_XMLOutputStream", _wrap_delete_XMLOutputStream, METH_O, "delete_XMLOutputStream(XMLOutputStream self)"},
	 { "XMLOutputStream_endElement", _wrap_XMLOutputStream_endElement, METH_VARARGS, "\n"
		"XMLOutputStream_endElement(XMLOutputStream self, string name, string prefix=\"\")\n"
		"XMLOutputStream_endElement(XMLOutputStream self, XMLTriple triple, bool text=False)\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    endElement(string name, string prefix = '')\n"
		"\n"
		"Writes the given XML end element name to this XMLOutputStream.\n"
		"\n"
		"Parameter 'name' is the name of the element.\n"
		"\n"
		"Parameter 'prefix' is an optional XML namespace prefix to write in\n"
		"front of the 'element' name.  (The result has the form prefix:name.)\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    endElement(XMLTriple triple, bool text = false)\n"
		"\n"
		"Writes the given element to the stream.\n"
		"\n"
		"Parameter 'triple' is the XML element to write. Parameter 'text' is\n"
		"the text to put\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "XMLOutputStream_setAutoIndent", _wrap_XMLOutputStream_setAutoIndent, METH_VARARGS, "\n"
		"XMLOutputStream_setAutoIndent(XMLOutputStream self, bool indent)\n"
		"\n"
		"Turns automatic indentation on or off for this XMLOutputStream.\n"
		"\n"
		"Parameter 'indent' is if 'True,' automatic indentation is turned on.\n"
		"\n"
		""},
	 { "XMLOutputStream_startElement", _wrap_XMLOutputStream_startElement, METH_VARARGS, "\n"
		"XMLOutputStream_startElement(XMLOutputStream self, string name, string prefix=\"\")\n"
		"XMLOutputStream_startElement(XMLOutputStream self, XMLTriple triple)\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    startElement(XMLTriple triple)\n"
		"\n"
		"Writes the given XML start element prefix:name on this output stream.\n"
		"\n"
		"Parameter 'triple' is the start element to write.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    startElement(string name, string prefix = '')\n"
		"\n"
		"Writes the given XML start element name to this XMLOutputStream.\n"
		"\n"
		"Parameter 'name' is the name of the element.\n"
		"\n"
		"Parameter 'prefix' is an optional XML namespace prefix to write in\n"
		"front of the 'element' name.  (The result has the form prefix:name.)\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "XMLOutputStream_startEndElement", _wrap_XMLOutputStream_startEndElement, METH_VARARGS, "\n"
		"XMLOutputStream_startEndElement(XMLOutputStream self, string name, string prefix=\"\")\n"
		"XMLOutputStream_startEndElement(XMLOutputStream self, XMLTriple triple)\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    startEndElement(XMLTriple triple)\n"
		"\n"
		"Writes the given start element to this output stream.\n"
		"\n"
		"Parameter 'triple' is the XML element to write.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    startEndElement(string name, string prefix = '')\n"
		"\n"
		"Writes the given XML start and end element name to this\n"
		"XMLOutputStream.\n"
		"\n"
		"Parameter 'name' is the name of the element.\n"
		"\n"
		"Parameter 'prefix' is an optional XML namespace prefix to write in\n"
		"front of the 'element' name.  (The result has the form prefix:name.)\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "XMLOutputStream_writeAttribute", _wrap_XMLOutputStream_writeAttribute, METH_VARARGS, "\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, string value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, string prefix, string value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, XMLTriple triple, string value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, char const * value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, string prefix, char const * value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, XMLTriple triple, char const * value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, bool const & value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, string prefix, bool const & value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, XMLTriple triple, bool const & value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, double const & value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, string prefix, double const & value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, XMLTriple triple, double const & value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, long const & value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, string prefix, long const & value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, XMLTriple triple, long const & value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, int const & value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, string prefix, int const & value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, XMLTriple triple, int const & value)\n"
		"XMLOutputStream_writeAttribute(XMLOutputStream self, string name, string prefix, unsigned int const & value)\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(XMLTriple triple, string value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'triple' is the attribute, in the form of an XMLTriple.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name, string prefix, long value)\n"
		"\n"
		"Writes the given namespace-prefixed attribute value to this output\n"
		"stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'prefix' is an XML namespace prefix to write in front of the\n"
		"'element' name.  (The result has the form prefix:name.)  See other\n"
		"versions of this method for a variant that does not require a prefix.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name, string prefix, string value)\n"
		"\n"
		"Writes the given namespace-prefixed attribute value to this output\n"
		"stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'prefix' is an XML namespace prefix to write in front of the\n"
		"'element' name.  (The result has the form prefix:name.)  See other\n"
		"versions of this method for a variant that does not require a prefix.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(XMLTriple triple,  bool value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'triple' is the attribute, in the form of an XMLTriple.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name, long value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(XMLTriple triple, long value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'triple' is the attribute, in the form of an XMLTriple.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(XMLTriple triple, long value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'triple' is the attribute, in the form of an XMLTriple.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name,  long value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name, string value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name, string value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name, string prefix,  long value)\n"
		"\n"
		"Writes the given namespace-prefixed attribute value to this output\n"
		"stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'prefix' is an XML namespace prefix to write in front of the\n"
		"'element' name.  (The result has the form prefix:name.)  See other\n"
		"versions of this method for a variant that does not require a prefix.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name, string prefix, long value)\n"
		"\n"
		"Writes the given namespace-prefixed attribute value to this output\n"
		"stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'prefix' is an XML namespace prefix to write in front of the\n"
		"'element' name.  (The result has the form prefix:name.)  See other\n"
		"versions of this method for a variant that does not require a prefix.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name, string prefix,  int value)\n"
		"\n"
		"Writes the given namespace-prefixed attribute value to this output\n"
		"stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'prefix' is an XML namespace prefix to write in front of the\n"
		"'element' name.  (The result has the form prefix:name.)  See other\n"
		"versions of this method for a variant that does not require a prefix.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(XMLTriple triple,  long value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'triple' is the attribute, in the form of an XMLTriple.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name,  int value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(XMLTriple triple,  int value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'triple' is the attribute, in the form of an XMLTriple.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name,  bool value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(XMLTriple triple, string value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'triple' is the attribute, in the form of an XMLTriple.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name, long value)\n"
		"\n"
		"Writes the given attribute and value to this output stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name, string prefix, string value)\n"
		"\n"
		"Writes the given namespace-prefixed attribute value to this output\n"
		"stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'prefix' is an XML namespace prefix to write in front of the\n"
		"'element' name.  (The result has the form prefix:name.)  See other\n"
		"versions of this method for a variant that does not require a prefix.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    writeAttribute(string name, string &prefix,  bool value)\n"
		"\n"
		"Writes the given namespace-prefixed attribute value to this output\n"
		"stream.\n"
		"\n"
		"Parameter 'name' is the name of the attribute.\n"
		"\n"
		"Parameter 'prefix' is an XML namespace prefix to write in front of the\n"
		"'element' name.  (The result has the form prefix:name.)  See other\n"
		"versions of this method for a variant that does not require a prefix.\n"
		"\n"
		"Parameter 'value' is the value of the attribute.\n"
		"\n"
		""},
	 { "XMLOutputStream_writeXMLDecl", _wrap_XMLOutputStream_writeXMLDecl, METH_O, "\n"
		"XMLOutputStream_writeXMLDecl(XMLOutputStream self)\n"
		"\n"
		"Writes a standard XML declaration to this output stream.\n"
		"\n"
		"The XML declaration has the form\n"
		"\n"
		"  <?xml version='1.0' encoding='UTF-8'?>\n"
		"\n"
		"Note that the SBML specifications require the use of UTF-8 encoding\n"
		"and version 1.0, so for SBML documents, the above is the standard XML\n"
		"declaration.\n"
		"\n"
		""},
	 { "XMLOutputStream_writeComment", _wrap_XMLOutputStream_writeComment, METH_VARARGS, "\n"
		"XMLOutputStream_writeComment(XMLOutputStream self, string programName, string programVersion, bool writeTimestamp=True)\n"
		"\n"
		"Writes an XML comment with the name and version of this program.\n"
		"\n"
		"The XML comment has the following form:\n"
		"\n"
		"  <!-- Created by <program name> version <program version>\n"
		"  on yyyy-MM-dd HH:mm with libSBML version <libsbml version>. -->\n"
		"\n"
		"See the class constructor for more information about this program\n"
		"comment.\n"
		"\n"
		"Parameter 'programName' is an optional program name to write as a\n"
		"comment in the output stream.\n"
		"\n"
		"Parameter 'programVersion' is an optional version identification\n"
		"string to write as a comment in the output stream.\n"
		"\n"
		"Parameter 'writeTimestamp' is an optional flag indicating that a\n"
		"timestamp should be written.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "XMLOutputStream_downIndent", _wrap_XMLOutputStream_downIndent, METH_O, "\n"
		"XMLOutputStream_downIndent(XMLOutputStream self)\n"
		"\n"
		"Decreases the indentation level for this XMLOutputStream.\n"
		"\n"
		"LibSBML tries to produce human-readable XML output by automatically\n"
		"indenting the bodies of elements.  Callers can manually control\n"
		"indentation further by using the XMLOutputStream.upIndent() and\n"
		"XMLOutputStream.downIndent() methods to increase and decrease,\n"
		"respectively, the current level of indentation in the XML output.\n"
		"\n"
		"See also upIndent().\n"
		"\n"
		""},
	 { "XMLOutputStream_upIndent", _wrap_XMLOutputStream_upIndent, METH_O, "\n"
		"XMLOutputStream_upIndent(XMLOutputStream self)\n"
		"\n"
		"Increases the indentation level for this XMLOutputStream.\n"
		"\n"
		"LibSBML tries to produce human-readable XML output by automatically\n"
		"indenting the bodies of elements.  Callers can manually control\n"
		"indentation further by using the XMLOutputStream.upIndent() and\n"
		"XMLOutputStream.downIndent() methods to increase and decrease,\n"
		"respectively, the current level of indentation in the XML output.\n"
		"\n"
		"See also downIndent().\n"
		"\n"
		""},
	 { "XMLOutputStream_getSBMLNamespaces", _wrap_XMLOutputStream_getSBMLNamespaces, METH_O, "\n"
		"XMLOutputStream_getSBMLNamespaces(XMLOutputStream self) -> SBMLNamespaces\n"
		"\n"
		"Returns the SBMLNamespaces object attached to this output stream.\n"
		"\n"
		"Returns the SBMLNamespaces object, or 'None' if none has been set.\n"
		"\n"
		""},
	 { "XMLOutputStream_setSBMLNamespaces", _wrap_XMLOutputStream_setSBMLNamespaces, METH_VARARGS, "\n"
		"XMLOutputStream_setSBMLNamespaces(XMLOutputStream self, SBMLNamespaces sbmlns)\n"
		"\n"
		"Sets the SBMLNamespaces object associated with this output stream.\n"
		"\n"
		"Parameter 'sbmlns' is the namespace object.\n"
		"\n"
		""},
	 { "XMLOutputStream_getWriteComment", _wrap_XMLOutputStream_getWriteComment, METH_NOARGS, "\n"
		"XMLOutputStream_getWriteComment() -> bool\n"
		"\n"
		"Returns a boolean, whether the output stream will write an XML comment\n"
		"at the top of the file. (Enabled by default.)\n"
		"\n"
		""},
	 { "XMLOutputStream_setWriteComment", _wrap_XMLOutputStream_setWriteComment, METH_O, "\n"
		"XMLOutputStream_setWriteComment(bool writeComment)\n"
		"\n"
		"sets a flag, whether the output stream will write an XML comment at\n"
		"the top of the file. (Enabled by default.)\n"
		"\n"
		"Parameter 'writeComment' is the flag.\n"
		"\n"
		""},
	 { "XMLOutputStream_getWriteTimestamp", _wrap_XMLOutputStream_getWriteTimestamp, METH_NOARGS, "\n"
		"XMLOutputStream_getWriteTimestamp() -> bool\n"
		"\n"
		"Returns a boolean, whether the output stream will write an XML comment\n"
		"with a timestamp at the top of the file. (Enabled by default.)\n"
		"\n"
		""},
	 { "XMLOutputStream_setWriteTimestamp", _wrap_XMLOutputStream_setWriteTimestamp, METH_O, "\n"
		"XMLOutputStream_setWriteTimestamp(bool writeTimestamp)\n"
		"\n"
		"sets a flag, whether the output stream will write an XML comment with\n"
		"a timestamp at the top of the file. (Enabled by default.)\n"
		"\n"
		"Parameter 'writeTimestamp' is the flag.\n"
		"\n"
		""},
	 { "XMLOutputStream_getLibraryName", _wrap_XMLOutputStream_getLibraryName, METH_NOARGS, "\n"
		"XMLOutputStream_getLibraryName() -> string\n"
		"\n"
		"Returns the name of the library to be used in comments ('libSBML' by\n"
		"default).\n"
		"\n"
		""},
	 { "XMLOutputStream_setLibraryName", _wrap_XMLOutputStream_setLibraryName, METH_O, "\n"
		"XMLOutputStream_setLibraryName(string libraryName)\n"
		"\n"
		"sets the name of the library writing the XML Parameter 'libraryName'\n"
		"is the name of the library to be used in comments.\n"
		"\n"
		""},
	 { "XMLOutputStream_getLibraryVersion", _wrap_XMLOutputStream_getLibraryVersion, METH_NOARGS, "\n"
		"XMLOutputStream_getLibraryVersion() -> string\n"
		"\n"
		"Returns a string representing the version of the library writing the\n"
		"output. This is the value of getLibSBMLDottedVersion() by default.\n"
		"\n"
		""},
	 { "XMLOutputStream_setLibraryVersion", _wrap_XMLOutputStream_setLibraryVersion, METH_O, "\n"
		"XMLOutputStream_setLibraryVersion(string libraryVersion)\n"
		"\n"
		"sets the name of the library writing the output\n"
		"\n"
		"Parameter 'libraryVersion' is the version information as string.\n"
		"\n"
		""},
	 { "XMLOutputStream_getIndent", _wrap_XMLOutputStream_getIndent, METH_O, "\n"
		"XMLOutputStream_getIndent(XMLOutputStream self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "XMLOutputStream_setIndent", _wrap_XMLOutputStream_setIndent, METH_VARARGS, "\n"
		"XMLOutputStream_setIndent(XMLOutputStream self, unsigned int indent)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "XMLOutputStream_writeAttributeBool", _wrap_XMLOutputStream_writeAttributeBool, METH_VARARGS, "\n"
		"XMLOutputStream_writeAttributeBool(XMLOutputStream self, string name, bool const & value)\n"
		"XMLOutputStream_writeAttributeBool(XMLOutputStream self, XMLTriple name, bool const & value)\n"
		"@internal\n"
		""},
	 { "XMLOutputStream_swigregister", XMLOutputStream_swigregister, METH_O, NULL},
	 { "XMLOutputStream_swiginit", XMLOutputStream_swiginit, METH_VARARGS, NULL},
	 { "new_XMLOwningOutputStringStream", _wrap_new_XMLOwningOutputStringStream, METH_VARARGS, "\n"
		"XMLOwningOutputStringStream(string encoding=\"UTF-8\", bool writeXMLDecl=True, string programName=\"\", string programVersion=\"\")\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "delete_XMLOwningOutputStringStream", _wrap_delete_XMLOwningOutputStringStream, METH_O, "delete_XMLOwningOutputStringStream(XMLOwningOutputStringStream self)"},
	 { "XMLOwningOutputStringStream_swigregister", XMLOwningOutputStringStream_swigregister, METH_O, NULL},
	 { "XMLOwningOutputStringStream_swiginit", XMLOwningOutputStringStream_swiginit, METH_VARARGS, NULL},
	 { "new_XMLOwningOutputFileStream", _wrap_new_XMLOwningOutputFileStream, METH_VARARGS, "\n"
		"XMLOwningOutputFileStream(string filename, string encoding=\"UTF-8\", bool writeXMLDecl=True, string programName=\"\", string programVersion=\"\")\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "delete_XMLOwningOutputFileStream", _wrap_delete_XMLOwningOutputFileStream, METH_O, "delete_XMLOwningOutputFileStream(XMLOwningOutputFileStream self)"},
	 { "XMLOwningOutputFileStream_swigregister", XMLOwningOutputFileStream_swigregister, METH_O, NULL},
	 { "XMLOwningOutputFileStream_swiginit", XMLOwningOutputFileStream_swiginit, METH_VARARGS, NULL},
	 { "new_XMLInputStream", _wrap_new_XMLInputStream, METH_VARARGS, "\n"
		"XMLInputStream(char const * content, bool isFile=True, string library=\"\", XMLErrorLog errorLog=None)\n"
		"\n"
		"Creates a new XMLInputStream.\n"
		"\n"
		"@param content the source of the stream.\n"
		"\n"
		"@param isFile a boolean flag to indicate whether @p content is a file\n"
		"name.  If @c true, @p content is assumed to be the file from which the\n"
		"XML content is to be read.  If @c false, @p content is taken to be a\n"
		"string that @em is the content to be read.\n"
		"\n"
		"@param library the name of the parser library to use.\n"
		"\n"
		"@param errorLog the XMLErrorLog object to use.\n"
		"\n"
		"@htmlinclude warn-default-args-in-docs.html\n"
		"\n"
		""},
	 { "delete_XMLInputStream", _wrap_delete_XMLInputStream, METH_O, "delete_XMLInputStream(XMLInputStream self)"},
	 { "XMLInputStream_getEncoding", _wrap_XMLInputStream_getEncoding, METH_O, "\n"
		"XMLInputStream_getEncoding(XMLInputStream self) -> string\n"
		"\n"
		"Returns the encoding of the XML stream.\n"
		"\n"
		"The encoding is indicated by the xml declaration at the beginning of\n"
		"an XML document or data stream.  The form of this declaration is\n"
		"\n"
		"  <?xml version='1.0' encoding='UTF-8'?>\n"
		"\n"
		"Note that the SBML specifications require the use of UTF-8 encoding,\n"
		"so for SBML documents, the value returned by this method will always\n"
		"be the string 'UTF-8'.\n"
		"\n"
		"Returns the encoding of the XML stream.\n"
		"\n"
		"See also getVersion().\n"
		"\n"
		""},
	 { "XMLInputStream_getVersion", _wrap_XMLInputStream_getVersion, METH_O, "\n"
		"XMLInputStream_getVersion(XMLInputStream self) -> string\n"
		"\n"
		"Returns the version of the XML stream.\n"
		"\n"
		"The version is indicated by the xml declaration at the beginning of an\n"
		"XML document or data stream.  The form of this declaration is\n"
		"\n"
		"   <?xml version='1.0' encoding='UTF-8'?>\n"
		"\n"
		"Note that the SBML specifications require the use of version 1.0, so\n"
		"for SBML documents, the value returned by this method will always be\n"
		"the string '1.0'.\n"
		"\n"
		"Returns the version of the XML stream.\n"
		"\n"
		"See also getEncoding().\n"
		"\n"
		""},
	 { "XMLInputStream_getErrorLog", _wrap_XMLInputStream_getErrorLog, METH_O, "\n"
		"XMLInputStream_getErrorLog(XMLInputStream self) -> XMLErrorLog\n"
		"\n"
		"Returns the XMLErrorLog used to log parsing problems.\n"
		"\n"
		"Returns the XMLErrorLog used to log XML parse errors and other\n"
		"validation errors (and messages).\n"
		"\n"
		""},
	 { "XMLInputStream_isEOF", _wrap_XMLInputStream_isEOF, METH_O, "\n"
		"XMLInputStream_isEOF(XMLInputStream self) -> bool\n"
		"\n"
		"Returns 'True' if end of file (stream) has been reached.\n"
		"\n"
		"Returns 'True' if end of file (stream) has been reached, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "XMLInputStream_isError", _wrap_XMLInputStream_isError, METH_O, "\n"
		"XMLInputStream_isError(XMLInputStream self) -> bool\n"
		"\n"
		"Returns 'True' if a fatal error occurred while reading from this\n"
		"stream.\n"
		"\n"
		"Returns 'True' if a fatal error occurred while reading from this\n"
		"stream.\n"
		"\n"
		""},
	 { "XMLInputStream_isGood", _wrap_XMLInputStream_isGood, METH_O, "\n"
		"XMLInputStream_isGood(XMLInputStream self) -> bool\n"
		"\n"
		"Returns 'True' if the stream is in a good state.\n"
		"\n"
		"The definition of 'good state' is that isEOF() and isError() both\n"
		"return 'False.'\n"
		"\n"
		"Returns 'True' if the stream is in a good state, 'False' otherwise.\n"
		"\n"
		""},
	 { "XMLInputStream_next", _wrap_XMLInputStream_next, METH_O, "\n"
		"XMLInputStream_next(XMLInputStream self) -> XMLToken\n"
		"\n"
		"Returns the next token on this XML input stream.\n"
		"\n"
		"The token is consumed in the process.\n"
		"\n"
		"Returns the next XMLToken, or an EOF token (i.e., XMLToken.isEOF() ==\n"
		"true).\n"
		"\n"
		"See also peek().\n"
		"\n"
		""},
	 { "XMLInputStream_peek", _wrap_XMLInputStream_peek, METH_O, "\n"
		"XMLInputStream_peek(XMLInputStream self) -> XMLToken\n"
		"\n"
		"Returns the next token without consuming it.\n"
		"\n"
		"A subsequent call to either peek() or next() will return the same\n"
		"token.\n"
		"\n"
		"Returns the next XMLToken or EOF (XMLToken.isEOF() == true).\n"
		"\n"
		"See also next().\n"
		"\n"
		""},
	 { "XMLInputStream_skipPastEnd", _wrap_XMLInputStream_skipPastEnd, METH_VARARGS, "\n"
		"XMLInputStream_skipPastEnd(XMLInputStream self, XMLToken element)\n"
		"\n"
		"Consume zero or more tokens up to and including the corresponding end\n"
		"element or EOF.\n"
		"\n"
		"Parameter 'element' is the element whose end will be sought in the\n"
		"input stream.\n"
		"\n"
		""},
	 { "XMLInputStream_skipText", _wrap_XMLInputStream_skipText, METH_O, "\n"
		"XMLInputStream_skipText(XMLInputStream self)\n"
		"\n"
		"Consume zero or more tokens up to but not including the next XML\n"
		"element or EOF.\n"
		"\n"
		""},
	 { "XMLInputStream_setErrorLog", _wrap_XMLInputStream_setErrorLog, METH_VARARGS, "\n"
		"XMLInputStream_setErrorLog(XMLInputStream self, XMLErrorLog log) -> int\n"
		"\n"
		"Sets the XMLErrorLog this stream will use to log errors.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "XMLInputStream_toString", _wrap_XMLInputStream_toString, METH_O, "\n"
		"XMLInputStream_toString(XMLInputStream self) -> string\n"
		"\n"
		"Prints a string representation of the underlying token stream.\n"
		"\n"
		"Returns a string representing the underlying XML token stream.\n"
		"\n"
		"Note: This method is intended for debugging purposes.\n"
		"\n"
		""},
	 { "XMLInputStream_getSBMLNamespaces", _wrap_XMLInputStream_getSBMLNamespaces, METH_O, "\n"
		"XMLInputStream_getSBMLNamespaces(XMLInputStream self) -> SBMLNamespaces\n"
		"\n"
		"Returns the SBMLNamespaces object attached to this XMLInputStream.\n"
		"\n"
		"Returns the SBMLNamespaces object or 'None' if none has been set.\n"
		"\n"
		""},
	 { "XMLInputStream_setSBMLNamespaces", _wrap_XMLInputStream_setSBMLNamespaces, METH_VARARGS, "\n"
		"XMLInputStream_setSBMLNamespaces(XMLInputStream self, SBMLNamespaces sbmlns)\n"
		"\n"
		"Sets the SBML namespaces associated with this XML input stream.\n"
		"\n"
		"This allows this stream to reference the available SBML namespaces\n"
		"being read.\n"
		"\n"
		"Parameter 'sbmlns' is the list of namespaces to use.\n"
		"\n"
		""},
	 { "XMLInputStream_determineNumberChildren", _wrap_XMLInputStream_determineNumberChildren, METH_VARARGS, "\n"
		"XMLInputStream_determineNumberChildren(XMLInputStream self, string elementName=\"\") -> unsigned int\n"
		"\n"
		"Returns the number of child tokens of the given element in this\n"
		"stream.\n"
		"\n"
		"This method allows information from the input stream to be determined\n"
		"without the need to actually read and consume the tokens in the\n"
		"stream. It returns the number of child elements of the element\n"
		"represented by the 'elementName', i.e., the number of child elements\n"
		"encountered before the closing tag for the 'elementName' supplied.\n"
		"\n"
		"If no 'elementName' is supplied or it is an empty string, then as a\n"
		"special case, this method assumes the element is a MathML apply\n"
		"element followed by a function name.\n"
		"\n"
		"Parameter 'elementName' is a string representing the name of the\n"
		"element for which the number of children are to be determined.\n"
		"\n"
		"Returns a long integer giving the number of children of the\n"
		"'elementName' specified.\n"
		"\n"
		"Note: This method assumes the stream has been read up to and including\n"
		"the element 'elementName'.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "XMLInputStream_determineNumSpecificChildren", _wrap_XMLInputStream_determineNumSpecificChildren, METH_VARARGS, "\n"
		"XMLInputStream_determineNumSpecificChildren(XMLInputStream self, string childName, string container) -> unsigned int\n"
		"\n"
		"Returns the number of child tokens of the specified type within a\n"
		"given container element.\n"
		"\n"
		"This method allows information from the input stream to be determined\n"
		"without the need to actually read and consume the tokens in the\n"
		"stream. It returns the number of child elements of the 'childName'\n"
		"element within the element specified by 'container'.  In other words,\n"
		"it counts the number of 'childName' elements encountered before the\n"
		"closing tag for the 'container' supplied.\n"
		"\n"
		"Parameter 'childName' is a string representing the name of the child\n"
		"element whose number is to be determined.\n"
		"\n"
		"Parameter 'container' is a string representing the name of the element\n"
		"for which the number of children are to be determined.\n"
		"\n"
		"Returns a long integer giving the number of children of type\n"
		"'childName' within the 'container' element.\n"
		"\n"
		"Note: This method assumes the stream has been read up to and including\n"
		"the element 'container'.\n"
		"\n"
		""},
	 { "XMLInputStream_containsChild", _wrap_XMLInputStream_containsChild, METH_VARARGS, "\n"
		"XMLInputStream_containsChild(XMLInputStream self, string childName, string container) -> bool\n"
		"\n"
		"Predicate returning 'True' if a child token of the specified type\n"
		"occurs  within a given container element.\n"
		"\n"
		"This method allows information from the input stream to be determined\n"
		"without the need to actually read and consume the tokens in the\n"
		"stream. It returns 'True' if the 'childName' element occurs at any\n"
		"point within the element specified by 'container'.\n"
		"\n"
		"Parameter 'childName' is a string representing the name of the child\n"
		"element whose presence is to be determined.\n"
		"\n"
		"Parameter 'container' is a string representing the name of the element\n"
		"for which the presence of the child element is to be determined.\n"
		"\n"
		"Returns boolean 'True' if a child of type 'childName' occurs within\n"
		"the 'container' element, 'False' otherwise.\n"
		"\n"
		"Note: This method assumes the stream has been read up to and including\n"
		"the element 'container'.\n"
		"\n"
		""},
	 { "XMLInputStream_swigregister", XMLInputStream_swigregister, METH_O, NULL},
	 { "XMLInputStream_swiginit", XMLInputStream_swiginit, METH_VARARGS, NULL},
	 { "new_XMLError", _wrap_new_XMLError, METH_VARARGS, "\n"
		"XMLError(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)\n"
		"new_XMLError(XMLError orig) -> XMLError\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLError(XMLError orig)\n"
		"\n"
		"Copy constructor; creates a copy of this XMLError.\n"
		"\n"
		"'orig' the XMLError object to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    XMLError(  int errorId           = 0 , string details  = '' ,\n"
		"long line     = 0 ,  long column   = 0 ,  long severity =\n"
		"LIBSBML_SEV_FATAL ,  long category = LIBSBML_CAT_INTERNAL )\n"
		"\n"
		"Creates a new XMLError to report that something occurred during XML\n"
		"processing.\n"
		"\n"
		"XMLError objects have identification numbers to indicate the nature of\n"
		"the exception.  These numbers are defined as longeger constants in the\n"
		"file 'libsbmlConstants.java'.  See the top of this documentation for a\n"
		"table listing the possible values and their meanings.  The argument\n"
		"'errorId' to this constructor can be (but does not have to be) a value\n"
		"from this set of constants.  If it is one of the predefined error\n"
		"identifiers, the XMLError class assumes the error is a low-level\n"
		"system or XML layer error and prepends a built-in, predefined error\n"
		"message to any string passed in the argument 'details' to this\n"
		"constructor.  In addition, all the predefined error identifiers have\n"
		"associated values for the 'severity' and 'category' codes, and these\n"
		"fields are filled-in as well.\n"
		"\n"
		"If the error identifier 'errorId' is a number greater than 9999, this\n"
		"constructor assumes that the error was generated from another part of\n"
		"the software, and does not do additional filling in of values beyond\n"
		"the defaults in the constructor itself.  This allows XMLError to serve\n"
		"as a base class for other errors (and is used in this way elsewhere in\n"
		"libSBML).  Callers should fill in all the parameters with suitable\n"
		"values if generating errors with codes greater than 9999 to make\n"
		"maximum use of the XMLError facilities.\n"
		"\n"
		"As mentioned above,  there are additional constants defined for\n"
		"standard severity and standard category codes, and every predefined\n"
		"error in libSBML has an associated value for severity and category\n"
		"taken from these predefined sets.  These constants have symbol names\n"
		"prefixed with LIBSBML_SEV_ and LIBSBML_CAT_, respectively.  If the\n"
		"value of 'errorId' is one of the standard error codes, callers do not\n"
		"need to fill in 'severity' and 'category' in a call to this\n"
		"constructor.  Conversely, if 'errorId' is not an existing XML-level\n"
		"error code, callers can use other values for 'severity' and\n"
		"'category'.\n"
		"\n"
		"Parameter 'errorId' is a long integer, the identification number of\n"
		"the error.\n"
		"\n"
		"Parameter 'details' is a string containing additional details about\n"
		"the error. If the error code in 'errorId' is one that is recognized by\n"
		"XMLError, the given message is appended to a predefined message\n"
		"associated with the given code.  If the error code is not recognized,\n"
		"the message is stored as-is as the text of the error.\n"
		"\n"
		"Parameter 'line' is a long integer, the line number at which the error\n"
		"occured.\n"
		"\n"
		"Parameter 'column' is a long integer, the column number at which the\n"
		"error occured.\n"
		"\n"
		"Parameter 'severity' is an integer indicating severity of the error.\n"
		"\n"
		"Parameter 'category' is an integer indicating the category to which\n"
		"the error belongs.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "delete_XMLError", _wrap_delete_XMLError, METH_O, "delete_XMLError(XMLError self)"},
	 { "XMLError_getErrorId", _wrap_XMLError_getErrorId, METH_O, "\n"
		"XMLError_getErrorId(XMLError self) -> unsigned int\n"
		"\n"
		"Returns the identifier of this error.\n"
		"\n"
		"Returns the error code for this error.\n"
		"\n"
		"See also getMessage(), getShortMessage(), getCategory(),\n"
		"getSeverity().\n"
		"\n"
		""},
	 { "XMLError_getMessage", _wrap_XMLError_getMessage, METH_O, "\n"
		"XMLError_getMessage(XMLError self) -> string\n"
		"\n"
		"Returns the message text of this error.\n"
		"\n"
		"The message associated with an error object describes the nature of\n"
		"the problem.  The message returned by this method is generally longer\n"
		"and clearer than the message returned by XMLError.getShortMessage(),\n"
		"but not in all cases.\n"
		"\n"
		"Callers may use XMLError.getCategory() and XMLError.getSeverity() to\n"
		"obtain additional information about the nature and severity of the\n"
		"problem.\n"
		"\n"
		"Returns the message text.\n"
		"\n"
		"See also getErrorId(), getShortMessage(), getCategory(),\n"
		"getSeverity().\n"
		"\n"
		""},
	 { "XMLError_getShortMessage", _wrap_XMLError_getShortMessage, METH_O, "\n"
		"XMLError_getShortMessage(XMLError self) -> string\n"
		"\n"
		"Returns a brief message for this error.\n"
		"\n"
		"This is an alternative error message that, in general, is as short as\n"
		"the authors could make it.  However, brevity is often inversely\n"
		"proportional to clarity, so this short message may not be sufficiently\n"
		"informative to understand the nature of the error.  Calling\n"
		"applications may wish to check XMLError.getMessage() in addition or\n"
		"instead.\n"
		"\n"
		"Returns the short error message text.\n"
		"\n"
		"See also getErrorId(), getMessage(), getCategory(), getSeverity().\n"
		"\n"
		""},
	 { "XMLError_getLine", _wrap_XMLError_getLine, METH_O, "\n"
		"XMLError_getLine(XMLError self) -> unsigned int\n"
		"\n"
		"Returns the line number in the XML input near where the error, warning\n"
		"or other diagnostic occurred.\n"
		"\n"
		"We say 'near where the problem occurred', because many factors affect\n"
		"how accurate the line/column information ultimately is.  For example,\n"
		"sometimes, the underlying XML parsers can only report such information\n"
		"for the parent XML element where an error occurs, and not for the\n"
		"specific point where the problem occurs.  In other situations, some\n"
		"parsers report invalid line and/or column numbers altogether.  If this\n"
		"occurs, libSBML sets the line and/or column number in the XMLError\n"
		"object to either 0 or the value of the maximum unsigned long integer\n"
		"representable on the platform where libSBML is running. The\n"
		"probability that a true line or column number in an SBML model would\n"
		"equal this value is vanishingly small; thus, if an application\n"
		"encounters these values in an XMLError object, it can assume no valid\n"
		"line/column number could be provided by libSBML in that situation.\n"
		"\n"
		"Returns the line number.\n"
		"\n"
		"See also getColumn().\n"
		"\n"
		""},
	 { "XMLError_getColumn", _wrap_XMLError_getColumn, METH_O, "\n"
		"XMLError_getColumn(XMLError self) -> unsigned int\n"
		"\n"
		"Returns the column number in the XML input near where the error,\n"
		"warning or other diagnostic occurred.\n"
		"\n"
		"We say 'near where the problem occurred', because many factors affect\n"
		"how accurate the line/column information ultimately is.  For example,\n"
		"sometimes, the underlying XML parsers can only report such information\n"
		"for the parent XML element where an error occurs, and not for the\n"
		"specific point where the problem occurs.  In other situations, some\n"
		"parsers report invalid line and/or column numbers altogether.  If this\n"
		"occurs, libSBML sets the line and/or column number in the XMLError\n"
		"object to either 0 or the value of the maximum unsigned long integer\n"
		"representable on the platform where libSBML is running. The\n"
		"probability that a true line or column number in an SBML model would\n"
		"equal this value is vanishingly small; thus, if an application\n"
		"encounters these values in an XMLError object, it can assume no valid\n"
		"line/column number could be provided by libSBML in that situation.\n"
		"\n"
		"Returns the column number.\n"
		"\n"
		"See also getLine().\n"
		"\n"
		""},
	 { "XMLError_getSeverity", _wrap_XMLError_getSeverity, METH_O, "\n"
		"XMLError_getSeverity(XMLError self) -> unsigned int\n"
		"\n"
		"Returns the severity of this error.\n"
		"\n"
		"XMLError defines an enumeration of severity codes for the XML layer.\n"
		"Applications that build on XMLError by subclassing it may add their\n"
		"own severity codes with numbers higher than those in the predefined\n"
		"set of severity codes.\n"
		"\n"
		"Returns the severity of this XMLError.\n"
		"\n"
		"See also getSeverityAsString(), getCategory().\n"
		"\n"
		""},
	 { "XMLError_getSeverityAsString", _wrap_XMLError_getSeverityAsString, METH_O, "\n"
		"XMLError_getSeverityAsString(XMLError self) -> string\n"
		"\n"
		"Returns a string describing the severity level of this error.\n"
		"\n"
		"XMLError defines an enumeration of severity codes for the XML layer.\n"
		"Applications that build on XMLError by subclassing it may add their\n"
		"own severity codes with numbers higher than those in the predefined\n"
		"set of severity codes.\n"
		"\n"
		"Returns string representing the severity of this XMLError.\n"
		"\n"
		"See also getSeverity(), getCategoryAsString().\n"
		"\n"
		""},
	 { "XMLError_getCategory", _wrap_XMLError_getCategory, METH_O, "\n"
		"XMLError_getCategory(XMLError self) -> unsigned int\n"
		"\n"
		"Returns the category of this error.\n"
		"\n"
		"XMLError defines an enumeration of category codes for the XML layer.\n"
		"Applications that build on XMLError by subclassing it may add their\n"
		"own categories with numbers higher than those in the predefined set of\n"
		"category codes.\n"
		"\n"
		"Categories can be used to partition errors into distinct groups. Among\n"
		"other things, this can be used to prevent id conflicts by uniquely\n"
		"identifying an XMLError by both id and category.\n"
		"\n"
		"Returns the category of this XMLError.\n"
		"\n"
		"See also getSeverity(), getCategoryAsString().\n"
		"\n"
		""},
	 { "XMLError_getCategoryAsString", _wrap_XMLError_getCategoryAsString, METH_O, "\n"
		"XMLError_getCategoryAsString(XMLError self) -> string\n"
		"\n"
		"Returns a string describing the category of this error.\n"
		"\n"
		"XMLError defines an enumeration of category codes for the XML layer.\n"
		"Applications that build on XMLError by subclassing it may add their\n"
		"own categories with numbers higher than those in the predefined set of\n"
		"category codes.\n"
		"\n"
		"Categories can be used to partition errors into distinct groups. Among\n"
		"other things, this can be used to prevent id conflicts by uniquely\n"
		"identifying an XMLError by both id and category.\n"
		"\n"
		"Returns string representing the category of this XMLError.\n"
		"\n"
		"See also getCategory(), getSeverityAsString().\n"
		"\n"
		""},
	 { "XMLError_isInfo", _wrap_XMLError_isInfo, METH_O, "\n"
		"XMLError_isInfo(XMLError self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this error\n"
		"object is for information purposes only.\n"
		"\n"
		"This is equivalent to obtaining the severity code from an XMLError\n"
		"object (via XMLError.getSeverity()) and then comparing it to the value\n"
		"LIBSBML_SEV_INFO from the set of predefined severity codes.\n"
		"\n"
		"Returns 'True' if this XMLError is for informational purposes only,\n"
		"'False' otherwise.\n"
		"\n"
		"See also isWarning(), isError(), isFatal().\n"
		"\n"
		""},
	 { "XMLError_isWarning", _wrap_XMLError_isWarning, METH_O, "\n"
		"XMLError_isWarning(XMLError self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether  this error\n"
		"object is a warning.\n"
		"\n"
		"This is equivalent to obtaining the severity code from an XMLError\n"
		"object (via XMLError.getSeverity()) and then comparing it to the value\n"
		"LIBSBML_SEV_WARNING from the set of predefined severity codes.\n"
		"\n"
		"Returns 'True' if this error is a warning, 'False' otherwise.\n"
		"\n"
		"See also isInfo(), isError(), isFatal().\n"
		"\n"
		""},
	 { "XMLError_isError", _wrap_XMLError_isError, METH_O, "\n"
		"XMLError_isError(XMLError self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this error\n"
		"is a significant error.\n"
		"\n"
		"This is equivalent to obtaining the severity code from an XMLError\n"
		"object (via XMLError.getSeverity()) and then comparing it to the value\n"
		"LIBSBML_SEV_ERROR from the set of predefined severity codes.\n"
		"\n"
		"Returns 'True' if this error is an error, 'False' otherwise.\n"
		"\n"
		"See also isInfo(), isWarning(), isFatal().\n"
		"\n"
		""},
	 { "XMLError_isFatal", _wrap_XMLError_isFatal, METH_O, "\n"
		"XMLError_isFatal(XMLError self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this error\n"
		"is a fatal run-time error.\n"
		"\n"
		"This is equivalent to obtaining the severity code from an XMLError\n"
		"object (via XMLError.getSeverity()) and then comparing it to the value\n"
		"LIBSBML_SEV_FATAL from the set of predefined severity codes.\n"
		"\n"
		"Returns 'True' if this error is a fatal error, 'False' otherwise.\n"
		"\n"
		"See also isInfo(), isWarning(), isError().\n"
		"\n"
		""},
	 { "XMLError_isInternal", _wrap_XMLError_isInternal, METH_O, "\n"
		"XMLError_isInternal(XMLError self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this error\n"
		"resulted from an internal program error.\n"
		"\n"
		"This is equivalent to obtaining the category identifier from an\n"
		"XMLError object (via XMLError.getCategory()) and then comparing it to\n"
		"the value LIBSBML_CAT_INTERNAL from the set of predefined category\n"
		"codes.\n"
		"\n"
		"Returns a boolean indicating whether the error is an internal error.\n"
		"\n"
		"See also isSystem(), isXML().\n"
		"\n"
		""},
	 { "XMLError_isSystem", _wrap_XMLError_isSystem, METH_O, "\n"
		"XMLError_isSystem(XMLError self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this error\n"
		"was generated by the operating system.\n"
		"\n"
		"This is equivalent to obtaining the category identifier from an\n"
		"XMLError object (via XMLError.getCategory()) and then comparing it to\n"
		"the value LIBSBML_CAT_SYSTEM from the set of predefined category\n"
		"codes.\n"
		"\n"
		"Returns boolean indicating whether the error is a system error.\n"
		"\n"
		"See also isInternal(), isXML().\n"
		"\n"
		""},
	 { "XMLError_isXML", _wrap_XMLError_isXML, METH_O, "\n"
		"XMLError_isXML(XMLError self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this error\n"
		"resulted from a problem in the XML input (e.g., an XML syntax error).\n"
		"\n"
		"This is equivalent to obtaining the category identifier from an\n"
		"XMLError object (via XMLError.getCategory()) and then comparing it to\n"
		"the value LIBSBML_CAT_XML from the set of predefined category codes.\n"
		"\n"
		"Returns a boolean indicating whether the error is an XML catetory\n"
		"error.\n"
		"\n"
		"See also isInternal(), isSystem().\n"
		"\n"
		""},
	 { "XMLError_isValid", _wrap_XMLError_isValid, METH_O, "\n"
		"XMLError_isValid(XMLError self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this error\n"
		"resulted from a problem or whether it was logged as an unknown error.\n"
		"\n"
		"This is equivalent to obtaining the error identifier from an XMLError\n"
		"object (via XMLError.getErrorId()) and then comparing it to the value\n"
		"XMLUnknownError or UnknownError from the set of predefined error\n"
		"codes.\n"
		"\n"
		"Returns a boolean indicating whether the error is a valid error\n"
		"('True)'  or whether it is unknown ('False).'\n"
		"\n"
		""},
	 { "XMLError_setLine", _wrap_XMLError_setLine, METH_VARARGS, "\n"
		"XMLError_setLine(XMLError self, unsigned int line) -> int\n"
		"\n"
		"Sets the line number where this error occurred.\n"
		"\n"
		"Parameter 'line' is a long integer, the line number to set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also setColumn().\n"
		"\n"
		""},
	 { "XMLError_setColumn", _wrap_XMLError_setColumn, METH_VARARGS, "\n"
		"XMLError_setColumn(XMLError self, unsigned int column) -> int\n"
		"\n"
		"Sets the column number where this error occurred.\n"
		"\n"
		"Parameter 'column' is a long integer, the column number to set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also setLine().\n"
		"\n"
		""},
	 { "XMLError_getStandardMessage", _wrap_XMLError_getStandardMessage, METH_O, "\n"
		"XMLError_getStandardMessage(int const code) -> string\n"
		"\n"
		"Returns a copy of the message string associated with the given\n"
		"predefined XMLError code.\n"
		"\n"
		"Parameter 'code' is the error code whose message is sought; it must be\n"
		"a predefined value from the set of predefined error identifiers.\n"
		"\n"
		""},
	 { "XMLError_getPackage", _wrap_XMLError_getPackage, METH_O, "\n"
		"XMLError_getPackage(XMLError self) -> string\n"
		"\n"
		"Returns the SBML Level 3 package extension (if any) that logged this\n"
		"error.\n"
		"\n"
		"Each error logged by an libSBML extension for SBML Level 3 packages\n"
		"includes a record of the package that logged it.  The field is a\n"
		"simple text string.  If the string is empty or has the value ''core','\n"
		"then the error came from libSBML core; otherwise, the string will be\n"
		"the short-form name of the package (e.g., ''comp'' for the\n"
		"Hierarchical Model Composition package).\n"
		"\n"
		"Returns a string representing the name of the package that logged this\n"
		"error.  If the error did not come from a package extension, the value\n"
		"will be the empty string or ''core'.'\n"
		"\n"
		""},
	 { "XMLError_getErrorIdOffset", _wrap_XMLError_getErrorIdOffset, METH_O, "\n"
		"XMLError_getErrorIdOffset(XMLError self) -> unsigned int\n"
		"\n"
		"Returns libSBML's internal numerical offset for the error code\n"
		"associated with this error.\n"
		"\n"
		"In the SBML Level 3 package specifications, package validation rules\n"
		"are identified by 5-digit numbers prefixed with the nickname of the\n"
		"package itself---e.g., \"comp-10101\", \"fbc-20301\", etc.\n"
		"Historically, libSBML reported error codes as pure integers, and some\n"
		"application software systems make decisions based on the numerical\n"
		"values of the error codes.  To permit these applications to continue\n"
		"to function in this fashion, libSBML internally continues to maintain\n"
		"error identifiers as pure integers.  To handle the possibility that\n"
		"errors may come from package extensions, libSBML uses numerical\n"
		"offsets added to the internal error codes.  These offsets add two\n"
		"leading digits to the regular 5-digit error codes; for example,\n"
		"\"comp\" error codes are stored as 1010101, 1020102, etc.  The offset\n"
		"in this case is 1000000.  Another package will have the offset\n"
		"2000000, yet another will have 3000000, etc.\n"
		"\n"
		"This method returns the integer offset in this error's error code.\n"
		"Calling applications can get the 5-digit package-specific number for a\n"
		"given error code by subtracting the offset from the value reported by\n"
		"getErrorId():\n"
		"\n"
		"   getErrorId() - getErrorIdOffset()\n"
		"\n"
		"When libSBML produces error messages, it combines the text string\n"
		"returned by getPackage() with the subtracted value of the error code,\n"
		"to produce a text string of the form \"comp-10101\".\n"
		"\n"
		"See also getErrorId(), getPackage().\n"
		"\n"
		""},
	 { "XMLError_swigregister", XMLError_swigregister, METH_O, NULL},
	 { "XMLError_swiginit", XMLError_swiginit, METH_VARARGS, NULL},
	 { "XMLErrorLog_getNumErrors", _wrap_XMLErrorLog_getNumErrors, METH_O, "\n"
		"XMLErrorLog_getNumErrors(XMLErrorLog self) -> unsigned int\n"
		"\n"
		"Returns the number of errors that have been logged.\n"
		"\n"
		"To retrieve individual errors from the log, callers may use\n"
		"XMLErrorLog.getError() .\n"
		"\n"
		"Returns the number of errors that have been logged.\n"
		"\n"
		""},
	 { "XMLErrorLog_getError", _wrap_XMLErrorLog_getError, METH_VARARGS, "\n"
		"XMLErrorLog_getError(XMLErrorLog self, unsigned int n) -> XMLError\n"
		"\n"
		"Returns the nth XMLError object in this log.\n"
		"\n"
		"Index 'n' is counted from 0.  Callers should first inquire about the\n"
		"number of items in the log by using the method getNumErrors().\n"
		"Attempts to use an error index number that exceeds the actual number\n"
		"of errors in the log will result in a 'None' being returned.\n"
		"\n"
		"Parameter 'n' is the index number of the error to retrieve (with 0\n"
		"being the first error).\n"
		"\n"
		"Returns the nth XMLError in this log, or 'None' if 'n' is greater than\n"
		"or equal to getNumErrors().\n"
		"\n"
		"See also getNumErrors().\n"
		"\n"
		""},
	 { "XMLErrorLog_clearLog", _wrap_XMLErrorLog_clearLog, METH_O, "\n"
		"XMLErrorLog_clearLog(XMLErrorLog self)\n"
		"\n"
		"Deletes all errors from this log.\n"
		"\n"
		""},
	 { "new_XMLErrorLog", _wrap_new_XMLErrorLog, METH_VARARGS, "\n"
		"XMLErrorLog()\n"
		"new_XMLErrorLog(XMLErrorLog other) -> XMLErrorLog\n"
		"\n"
		"@internal\n"
		"\n"
		""},
	 { "delete_XMLErrorLog", _wrap_delete_XMLErrorLog, METH_O, "delete_XMLErrorLog(XMLErrorLog self)"},
	 { "XMLErrorLog_add", _wrap_XMLErrorLog_add, METH_VARARGS, "\n"
		"XMLErrorLog_add(XMLErrorLog self, XMLError error)\n"
		"XMLErrorLog_add(XMLErrorLog self, std::vector< XMLError * > const & errors)\n"
		""},
	 { "XMLErrorLog_toString", _wrap_XMLErrorLog_toString, METH_O, "\n"
		"XMLErrorLog_toString(XMLErrorLog self) -> string\n"
		"\n"
		"Writes all errors contained in this log to a string and returns it.\n"
		"\n"
		"This method uses printErrors() to format the diagnostic messages.\n"
		"Please consult that method for information about the organization of\n"
		"the messages in the string returned by this method.\n"
		"\n"
		"Returns a string containing all logged errors and warnings.\n"
		"\n"
		"See also printErrors().\n"
		"\n"
		""},
	 { "XMLErrorLog_printErrors", _wrap_XMLErrorLog_printErrors, METH_VARARGS, "\n"
		"XMLErrorLog_printErrors(XMLErrorLog self, ostream stream=cerr)\n"
		"XMLErrorLog_printErrors(XMLErrorLog self, ostream stream, unsigned int severity)\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    printErrors(std::ostream stream, long severity)\n"
		"\n"
		"Prints the errors or warnings with given severity stored in this error\n"
		"log.\n"
		"\n"
		"This method prints the text to the stream given by the optional\n"
		"parameter 'stream'.  If no stream is given, the method prints the\n"
		"output to the standard error stream.\n"
		"\n"
		"The format of the output is:\n"
		"\n"
		"     N error(s):\n"
		"       line NNN: (id) message\n"
		"\n"
		"If no errors with that severity was found, then no output will be\n"
		"produced.\n"
		"\n"
		"Parameter 'stream' is the ostream or ostringstream object indicating\n"
		"where the output should be printed. Parameter 'severity' is the\n"
		"severity of the errors sought.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    printErrors(std::ostream stream = std::cerr)\n"
		"\n"
		"Prints all the errors or warnings stored in this error log.\n"
		"\n"
		"This method prints the text to the stream given by the optional\n"
		"parameter 'stream'.  If no stream is given, the method prints the\n"
		"output to the standard error stream.\n"
		"\n"
		"The format of the output is:\n"
		"\n"
		"     N error(s):\n"
		"       line NNN: (id) message\n"
		"\n"
		"If no errors have occurred, i.e., getNumErrors() == 0, then no output\n"
		"will be produced. Parameter 'stream' is the ostream or ostringstream\n"
		"object indicating where the output should be printed.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "XMLErrorLog_isSeverityOverridden", _wrap_XMLErrorLog_isSeverityOverridden, METH_O, "\n"
		"XMLErrorLog_isSeverityOverridden(XMLErrorLog self) -> bool\n"
		"\n"
		"Returns a boolean indicating whether or not the severity has been\n"
		"overridden.\n"
		"\n"
		"The severity override mechanism in XMLErrorLog is intended to help\n"
		"applications handle error conditions in ways that may be more\n"
		"convenient for those applications.  It is possible to use the\n"
		"mechanism to override the severity code of errors logged by libSBML,\n"
		"and even to disable error logging completely.  An override stays in\n"
		"effect until the override is changed again by the calling application.\n"
		"\n"
		"Returns 'True' if an error severity override has been set, 'False'\n"
		"otherwise.\n"
		"\n"
		"See also getSeverityOverride(), setSeverityOverride(),\n"
		"unsetSeverityOverride(), changeErrorSeverity().\n"
		"\n"
		""},
	 { "XMLErrorLog_unsetSeverityOverride", _wrap_XMLErrorLog_unsetSeverityOverride, METH_O, "\n"
		"XMLErrorLog_unsetSeverityOverride(XMLErrorLog self)\n"
		"\n"
		"Usets an existing override.\n"
		"\n"
		"The severity override mechanism in XMLErrorLog is intended to help\n"
		"applications handle error conditions in ways that may be more\n"
		"convenient for those applications.  It is possible to use the\n"
		"mechanism to override the severity code of errors logged by libSBML,\n"
		"and even to disable error logging completely.  An override stays in\n"
		"effect until the override is changed again by the calling application.\n"
		"\n"
		"See also getSeverityOverride(), setSeverityOverride(),\n"
		"isSeverityOverridden(), changeErrorSeverity().\n"
		"\n"
		""},
	 { "XMLErrorLog_getSeverityOverride", _wrap_XMLErrorLog_getSeverityOverride, METH_O, "\n"
		"XMLErrorLog_getSeverityOverride(XMLErrorLog self) -> XMLErrorSeverityOverride_t\n"
		"\n"
		"Returns the current override.\n"
		"\n"
		"The severity override mechanism in XMLErrorLog is intended to help\n"
		"applications handle error conditions in ways that may be more\n"
		"convenient for those applications.  It is possible to use the\n"
		"mechanism to override the severity code of errors logged by libSBML,\n"
		"and even to disable error logging completely.  An override stays in\n"
		"effect until the override is changed again by the calling application.\n"
		"\n"
		"Returns a severity override code.  The possible values are drawn from\n"
		"the set of integer constants whose names begin with the prefix\n"
		"LIBSBML_OVERRIDE_:\n"
		"\n"
		"* LIBSBML_OVERRIDE_DISABLED\n"
		"\n"
		"* LIBSBML_OVERRIDE_DONT_LOG\n"
		"\n"
		"* LIBSBML_OVERRIDE_WARNING\n"
		"\n"
		"See also isSeverityOverridden(), setSeverityOverride(),\n"
		"unsetSeverityOverride(), changeErrorSeverity().\n"
		"\n"
		""},
	 { "XMLErrorLog_setSeverityOverride", _wrap_XMLErrorLog_setSeverityOverride, METH_VARARGS, "\n"
		"XMLErrorLog_setSeverityOverride(XMLErrorLog self, XMLErrorSeverityOverride_t severity)\n"
		"\n"
		"Set the severity override.\n"
		"\n"
		"The severity override mechanism in XMLErrorLog is intended to help\n"
		"applications handle error conditions in ways that may be more\n"
		"convenient for those applications.  It is possible to use the\n"
		"mechanism to override the severity code of errors logged by libSBML,\n"
		"and even to disable error logging completely.  An override stays in\n"
		"effect until the override is changed again by the calling application.\n"
		"\n"
		"Parameter 'severity' is an override code indicating what to do.  If\n"
		"the value is LIBSBML_OVERRIDE_DISABLED (the default setting) all\n"
		"errors logged will be given the severity specified in their usual\n"
		"definition.   If the value is LIBSBML_OVERRIDE_WARNING, then all\n"
		"errors will be logged as warnings.  If the value is\n"
		"LIBSBML_OVERRIDE_DONT_LOG, no error will be logged, regardless of\n"
		"their severity.\n"
		"\n"
		"See also isSeverityOverridden(), getSeverityOverride(),\n"
		"unsetSeverityOverride(), changeErrorSeverity().\n"
		"\n"
		""},
	 { "XMLErrorLog_changeErrorSeverity", _wrap_XMLErrorLog_changeErrorSeverity, METH_VARARGS, "\n"
		"XMLErrorLog_changeErrorSeverity(XMLErrorLog self, XMLErrorSeverity_t originalSeverity, XMLErrorSeverity_t targetSeverity, string package=\"all\")\n"
		"\n"
		"Changes the severity override for errors in the log that have a given\n"
		"severity.\n"
		"\n"
		"This method searches through the list of errors in the log, comparing\n"
		"each one's severity to the value of 'originalSeverity'.  For each\n"
		"error encountered with that severity logged by the named 'package',\n"
		"the severity of the error is reset to 'targetSeverity'.\n"
		"\n"
		"The severity override mechanism in XMLErrorLog is intended to help\n"
		"applications handle error conditions in ways that may be more\n"
		"convenient for those applications.  It is possible to use the\n"
		"mechanism to override the severity code of errors logged by libSBML,\n"
		"and even to disable error logging completely.  An override stays in\n"
		"effect until the override is changed again by the calling application.\n"
		"\n"
		"Parameter 'originalSeverity' is the severity code to match.\n"
		"\n"
		"Parameter 'targetSeverity' is the severity code to use as the new\n"
		"severity.\n"
		"\n"
		"Parameter 'package' is a string, the name of an SBML Level 3 package\n"
		"extension to use to narrow the search for errors.  A value of ''all''\n"
		"signifies to match against errors logged from any package; a value of\n"
		"a package nickname such as ''comp'' signifies to limit consideration\n"
		"to errors from just that package.  If no value is provided, ''all'' is\n"
		"the default.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"See also isSeverityOverridden(), getSeverityOverride(),\n"
		"setSeverityOverride(), unsetSeverityOverride().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "XMLErrorLog_contains", _wrap_XMLErrorLog_contains, METH_VARARGS, "\n"
		"XMLErrorLog_contains(XMLErrorLog self, unsigned int const errorId) -> bool\n"
		"\n"
		"Returns 'True' if XMLErrorLog contains an errorId\n"
		"\n"
		"Parameter 'errorId' is the error identifier of the error to be found.\n"
		"\n"
		""},
	 { "XMLErrorLog_swigregister", XMLErrorLog_swigregister, METH_O, NULL},
	 { "XMLErrorLog_swiginit", XMLErrorLog_swiginit, METH_VARARGS, NULL},
	 { "SBMLErrorLog_getError", _wrap_SBMLErrorLog_getError, METH_VARARGS, "\n"
		"SBMLErrorLog_getError(SBMLErrorLog self, unsigned int n) -> SBMLError\n"
		"\n"
		"Returns the nth SBMLError object in this log.\n"
		"\n"
		"Index 'n' is counted from 0.  Callers should first inquire about the\n"
		"number of items in the log by using the getNumErrors() method.\n"
		"Attempts to use an error index number that exceeds the actual number\n"
		"of errors in the log will result in a 'None' being returned.\n"
		"\n"
		"Parameter 'n' is the index number of the error to retrieve (with 0\n"
		"being the first error).\n"
		"\n"
		"Returns the nth SBMLError in this log, or 'None' if 'n' is greater\n"
		"than or equal to getNumErrors().\n"
		"\n"
		"See also getNumErrors().\n"
		"\n"
		""},
	 { "SBMLErrorLog_getErrorWithSeverity", _wrap_SBMLErrorLog_getErrorWithSeverity, METH_VARARGS, "\n"
		"SBMLErrorLog_getErrorWithSeverity(SBMLErrorLog self, unsigned int n, unsigned int severity) -> SBMLError\n"
		"\n"
		"Returns the nth SBMLError object with given severity in this log.\n"
		"\n"
		"Index 'n' is counted from 0.  Callers should first inquire about the\n"
		"number of items in the log by using the getNumFailsWithSeverity()\n"
		"method. Attempts to use an error index number that exceeds the actual\n"
		"number of errors in the log will result in a 'None' being returned.\n"
		"\n"
		"Parameter 'n' is the index number of the error to retrieve (with 0\n"
		"being the first error). Parameter 'severity' is the severity of the\n"
		"error to retrieve.\n"
		"\n"
		"Returns the nth SBMLError in this log, or 'None' if 'n' is greater\n"
		"than or equal to getNumFailsWithSeverity().\n"
		"\n"
		"See also getNumFailsWithSeverity().\n"
		"\n"
		""},
	 { "SBMLErrorLog_getNumFailsWithSeverity", _wrap_SBMLErrorLog_getNumFailsWithSeverity, METH_VARARGS, "\n"
		"SBMLErrorLog_getNumFailsWithSeverity(SBMLErrorLog self, unsigned int severity) -> unsigned int\n"
		"SBMLErrorLog_getNumFailsWithSeverity(SBMLErrorLog self, unsigned int severity) -> unsigned int\n"
		"\n"
		"Returns the number of errors that have been logged with the given\n"
		"severity code.\n"
		"\n"
		"LibSBML associates severity levels with every SBMLError object to\n"
		"provide an indication of how serious the problem is.  Severities range\n"
		"from informational diagnostics to fatal (irrecoverable) errors.  Given\n"
		"an SBMLError object instance, a caller can interrogate it for its\n"
		"severity level using methods such as SBMLError.getSeverity(),\n"
		"SBMLError.isFatal(), and so on.  The present method encapsulates\n"
		"iteration and interrogation of all objects in an SBMLErrorLog, making\n"
		"it easy to check for the presence of error objects with specific\n"
		"severity levels.\n"
		"\n"
		"Parameter 'severity' is a value from the set of LIBSBML_SEV_ constants\n"
		"defined by the interface class libsbml.\n"
		"\n"
		"Returns a count of the number of errors with the given severity code.\n"
		"\n"
		"See also getNumErrors().\n"
		"\n"
		""},
	 { "new_SBMLErrorLog", _wrap_new_SBMLErrorLog, METH_VARARGS, "\n"
		"SBMLErrorLog()\n"
		"new_SBMLErrorLog(SBMLErrorLog orig) -> SBMLErrorLog\n"
		"\n"
		"@internal\n"
		"\n"
		""},
	 { "delete_SBMLErrorLog", _wrap_delete_SBMLErrorLog, METH_O, "delete_SBMLErrorLog(SBMLErrorLog self)"},
	 { "SBMLErrorLog_logError", _wrap_SBMLErrorLog_logError, METH_VARARGS, "\n"
		"SBMLErrorLog_logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level=SBML_DEFAULT_LEVEL, unsigned int const version=SBML_DEFAULT_VERSION, string details=\"\", unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_UNKNOWN, unsigned int const category=LIBSBML_CAT_SBML)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLErrorLog_logPackageError", _wrap_SBMLErrorLog_logPackageError, METH_VARARGS, "\n"
		"SBMLErrorLog_logPackageError(SBMLErrorLog self, string package=\"core\", unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level=SBML_DEFAULT_LEVEL, unsigned int const version=SBML_DEFAULT_VERSION, string details=\"\", unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_UNKNOWN, unsigned int const category=LIBSBML_CAT_SBML)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLErrorLog_add", _wrap_SBMLErrorLog_add, METH_VARARGS, "SBMLErrorLog_add(SBMLErrorLog self, SBMLError error)"},
	 { "SBMLErrorLog_remove", _wrap_SBMLErrorLog_remove, METH_VARARGS, "\n"
		"SBMLErrorLog_remove(SBMLErrorLog self, unsigned int const errorId)\n"
		"\n"
		"Removes an error having errorId from the SBMLError list.\n"
		"\n"
		"Only the first item will be removed if there are multiple errors with\n"
		"the given errorId.\n"
		"\n"
		"Parameter 'errorId' is the error identifier of the error to be\n"
		"removed.\n"
		"\n"
		""},
	 { "SBMLErrorLog_removeAll", _wrap_SBMLErrorLog_removeAll, METH_VARARGS, "\n"
		"SBMLErrorLog_removeAll(SBMLErrorLog self, unsigned int const errorId)\n"
		"\n"
		"Removes all errors having errorId from the SBMLError list.\n"
		"\n"
		"Parameter 'errorId' is the error identifier of the error to be\n"
		"removed.\n"
		"\n"
		""},
	 { "SBMLErrorLog_contains", _wrap_SBMLErrorLog_contains, METH_VARARGS, "\n"
		"SBMLErrorLog_contains(SBMLErrorLog self, unsigned int const errorId) -> bool\n"
		"\n"
		"Returns 'True' if SBMLErrorLog contains an errorId\n"
		"\n"
		"Parameter 'errorId' is the error identifier of the error to be found.\n"
		"\n"
		""},
	 { "SBMLErrorLog_swigregister", SBMLErrorLog_swigregister, METH_O, NULL},
	 { "SBMLErrorLog_swiginit", SBMLErrorLog_swiginit, METH_VARARGS, NULL},
	 { "new_SBMLError", _wrap_new_SBMLError, METH_VARARGS, "\n"
		"SBMLError(unsigned int const errorId=0, unsigned int const level=SBML_DEFAULT_LEVEL, unsigned int const version=SBML_DEFAULT_VERSION, string details=\"\", unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_UNKNOWN, unsigned int const category=LIBSBML_CAT_SBML, string package=\"core\", unsigned int const pkgVersion=1)\n"
		"new_SBMLError(SBMLError orig) -> SBMLError\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLError(SBMLError orig)\n"
		"\n"
		"Copy constructor; creates a copy of this SBMLError.\n"
		"\n"
		"Parameter 'orig' is the instance to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLError(  long errorId  = 0 ,  long level    =\n"
		"SBML_DEFAULT_LEVEL ,  long version  = SBML_DEFAULT_VERSION , string\n"
		"details  = '' ,  long line     = 0 ,  long column   = 0 ,  long\n"
		"severity = LIBSBML_SEV_UNKNOWN ,  long category = LIBSBML_CAT_SBML ,\n"
		"string package  = 'core' ,  long pkgVersion = 1 )\n"
		"\n"
		"Creates a new SBMLError to report that something occurred during SBML\n"
		"processing.\n"
		"\n"
		"When a libSBML operation on SBML content results in a warning, error\n"
		"or other diagnostic, the issue is reported as an SBMLError object.\n"
		"SBMLError objects have identification numbers to indicate the nature\n"
		"of the exception.  These numbers are defined as longeger constants in\n"
		"the interface class libsbml.  See the top of this documentation page\n"
		"for a table listing the possible values and their meanings.  The\n"
		"argument 'errorId' to this constructor can be (but does not have to\n"
		"be) a value from this set of constants.  If it is one of the\n"
		"predefined error identifiers, the SBMLError class assumes the error is\n"
		"a low-level system or SBML layer error and prepends a built-in,\n"
		"predefined error message to any string passed in the argument\n"
		"'details' to this constructor.  In addition, all the predefined error\n"
		"identifiers have associated values for the 'severity' and 'category'\n"
		"codes, and these fields are filled-in using the libSBML defaults for\n"
		"each different error identifier.\n"
		"\n"
		"If the error identifier 'errorId' is a number greater than 99999, the\n"
		"SBMLError class assumes the error was generated from another part of\n"
		"the software and does not do additional filling in of values beyond\n"
		"the default in the constructor itself.  This allows SBMLError to serve\n"
		"as a base class for other errors, such as for user-defined validation\n"
		"rules (see Validator).  Callers should fill in all the parameters with\n"
		"suitable values if generating errors with codes greater than 99999 to\n"
		"make maximum use of the SBMLError facilities.\n"
		"\n"
		"As mentioned above, there are additional constants defined for\n"
		"standard severity and standard category codes, and every predefined\n"
		"error in libSBML has an associated value for severity and category\n"
		"taken from these predefined sets.  These constants have symbol names\n"
		"prefixed with LIBSBML_SEV_ and LIBSBML_CAT_, respectively.  If the\n"
		"value of 'errorId' is one of the standard error codes, callers do not\n"
		"need to fill in 'severity' and 'category' in a call to this\n"
		"constructor.  Conversely, if 'errorId' is not an existing SBML-level\n"
		"error code, callers can use other values for 'severity' and\n"
		"'category'.\n"
		"\n"
		"Please see the top of the documentation for SBMLError for a longer\n"
		"discussion of the possible error codes, their meanings, and their\n"
		"applicability to different combinations of Level+Version of SBML.\n"
		"\n"
		"Parameter 'errorId' is a long integer, the identification number of\n"
		"the error.\n"
		"\n"
		"Parameter 'level' is the SBML Level of the SBML model.\n"
		"\n"
		"Parameter 'version' is the SBML Version within the Level of the SBML\n"
		"model.\n"
		"\n"
		"Parameter 'details' is a string containing additional details about\n"
		"the error. If the error code in 'errorId' is one that is recognized by\n"
		"SBMLError, the given message is appended to a predefined message\n"
		"associated with the given code.  If the error code is not recognized,\n"
		"the message is stored as-is as the text of the error.\n"
		"\n"
		"Parameter 'line' is a long integer, the line number at which the error\n"
		"occured.\n"
		"\n"
		"Parameter 'column' is a long integer, the column number at which the\n"
		"error occured.\n"
		"\n"
		"Parameter 'severity' is an integer indicating severity of the error.\n"
		"\n"
		"Parameter 'category' is an integer indicating the category to which\n"
		"the error belongs.\n"
		"\n"
		"Parameter 'package' is the SBML Level package involved.\n"
		"\n"
		"Parameter 'pkgVersion' is the version of the 'package'.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "delete_SBMLError", _wrap_delete_SBMLError, METH_O, "delete_SBMLError(SBMLError self)"},
	 { "SBMLError_swigregister", SBMLError_swigregister, METH_O, NULL},
	 { "SBMLError_swiginit", SBMLError_swiginit, METH_VARARGS, NULL},
	 { "delete_CVTerm", _wrap_delete_CVTerm, METH_O, "delete_CVTerm(CVTerm self)"},
	 { "new_CVTerm", _wrap_new_CVTerm, METH_VARARGS, "\n"
		"CVTerm(QualifierType_t type=UNKNOWN_QUALIFIER)\n"
		"CVTerm(XMLNode node)\n"
		"new_CVTerm(CVTerm orig) -> CVTerm\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    CVTerm(CVTerm orig)\n"
		"\n"
		"Copy constructor; creates a copy of a CVTerm object.\n"
		"\n"
		"Parameter 'orig' is the CVTerm instance to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    CVTerm( XMLNode node)\n"
		"\n"
		"Creates a new CVTerm from the given XMLNode.\n"
		"\n"
		"The SBML Level 2 and Level 3 specifications define a simple format\n"
		"for annotating models when (a) referring to controlled vocabulary\n"
		"terms and database identifiers that define and describe biological and\n"
		"other entities, and (b) describing the creator of a model and the\n"
		"model's modification history.  The annotation content is stored in\n"
		"<annotation> elements attached to individual SBML elements.  The\n"
		"format for storing the content inside SBML <annotation> elements is a\n"
		"subset of W3C RDF (Resource Description Format) expressed in XML.  The\n"
		"CVTerm class provides a programming interface for working directly\n"
		"with controlled vocabulary term ('CV term') objects without having to\n"
		"deal directly with the XML form. When libSBML reads in an SBML model\n"
		"containing RDF annotations, it parses those annotations into a list of\n"
		"CVTerm objects, and when writing a model, it parses the CVTerm objects\n"
		"back into the appropriate SBML <annotation> structure.\n"
		"\n"
		"This method creates a CVTerm object from the given XMLNode object\n"
		"'node'.  XMLNode is libSBML's representation of a node in an XML tree\n"
		"of elements, and each such element can be placed in a namespace.  This\n"
		"constructor looks for the element to be in the XML namespaces\n"
		"'http://biomodels.net/model-qualifiers' (for model qualifiers) and\n"
		"'http://biomodels.net/biology-qualifiers' (for biological qualifier),\n"
		"and if they are, creates CVTerm objects for the result.\n"
		"\n"
		"Parameter 'node' is an XMLNode representing a CVTerm.\n"
		"\n"
		"Note: This method assumes that the given XMLNode object 'node' is of\n"
		"the correct structural form.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    CVTerm(QualifierType_t type = UNKNOWN_QUALIFIER)\n"
		"\n"
		"Creates an empty CVTerm, optionally with the given qualifier 'type' .\n"
		"\n"
		"The SBML Level 2 and Level 3 specifications define a simple format\n"
		"for annotating models when (a) referring to controlled vocabulary\n"
		"terms and database identifiers that define and describe biological and\n"
		"other entities, and (b) describing the creator of a model and the\n"
		"model's modification history.  The annotation content is stored in\n"
		"<annotation> elements attached to individual SBML elements.  The\n"
		"format for storing the content inside SBML <annotation> elements is a\n"
		"subset of W3C RDF (Resource Description Format) expressed in XML.  The\n"
		"CVTerm class provides a programming interface for working directly\n"
		"with controlled vocabulary term ('CV term') objects without having to\n"
		"deal directly with the XML form. When libSBML reads in an SBML model\n"
		"containing RDF annotations, it parses those annotations into a list of\n"
		"CVTerm objects, and when writing a model, it parses the CVTerm objects\n"
		"back into the appropriate SBML <annotation> structure.\n"
		"\n"
		"This method creates an empty CVTerm object.  The possible qualifier\n"
		"types usable as values of 'type' are MODEL_QUALIFIER and\n"
		"BIOLOGICAL_QUALIFIER.  If an explicit value for 'type' is not given,\n"
		"this method defaults to using UNKNOWN_QUALIFIER.  The qualifier type\n"
		"can be set later using the CVTerm.setQualifierType() method.\n"
		"\n"
		"Different BioModels.net qualifier elements encode different types of\n"
		"relationships.  Please refer to the SBML specification or the\n"
		"BioModels.net qualifiers web page for an explanation of the meaning of\n"
		"these different qualifiers.\n"
		"\n"
		"Parameter 'type' is a qualifier type.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "CVTerm_clone", _wrap_CVTerm_clone, METH_O, "\n"
		"CVTerm_clone(CVTerm self) -> CVTerm\n"
		"\n"
		"Creates and returns a deep copy of this CVTerm object.\n"
		"\n"
		"Returns the (deep) copy of this CVTerm object.\n"
		"\n"
		""},
	 { "CVTerm_getQualifierType", _wrap_CVTerm_getQualifierType, METH_VARARGS, "\n"
		"CVTerm_getQualifierType(CVTerm self) -> QualifierType_t\n"
		"CVTerm_getQualifierType(CVTerm self) -> QualifierType_t\n"
		"\n"
		"Returns the qualifier type of this CVTerm object.\n"
		"\n"
		"The RDF element used in the SBML format for referring to external\n"
		"entities is <rdf:Description>, with a <rdf:Bag> element inside of it\n"
		"containing one or more <rdf:li> elements.  The following template\n"
		"illustrates the structure:\n"
		"\n"
		"  <rdf:Description rdf:about=\"#meta id\">\n"
		"    HISTORY\n"
		"    <RELATION_ELEMENT>\n"
		"      <rdf:Bag>\n"
		"      <rdf:li rdf:resource=\"resource URI\" />\n"
		"      ...\n"
		"      </rdf:Bag>\n"
		"    </RELATION_ELEMENT>\n"
		"    ...\n"
		"  </rdf:Description>\n"
		"\n"
		"In the template above, the placeholder meta id stands for the\n"
		"element's meta identifier, which is a field available on all SBML\n"
		"components derived from the SBase base object class.  The dotted\n"
		"portions are optional, and the ellipses ... are placeholders for zero\n"
		"or more elements of the same form as the immediately preceding\n"
		"element.\n"
		"\n"
		"The placeholder  RELATION_ELEMENT refers to a BioModels.net qualifier\n"
		"element name.  This is an element in either the XML namespace\n"
		"'http://biomodels.net/model-qualifiers' (for model qualifiers) or\n"
		"'http://biomodels.net/biology-qualifiers' (for biological qualifier).\n"
		"The present method returns a code identifying which one of these two\n"
		"relationship namespaces is being used; any other qualifier in libSBML\n"
		"is considered unknown (as far as the CVTerm class is concerned).\n"
		"Consequently, this method will return one of the following values:\n"
		"\n"
		"* MODEL_QUALIFIER\n"
		"\n"
		"* BIOLOGICAL_QUALIFIER\n"
		"\n"
		"* UNKNOWN_QUALIFIER\n"
		"\n"
		"The specific relationship of this CVTerm to the enclosing SBML object\n"
		"can be determined using the CVTerm methods such as\n"
		"CVTerm.getModelQualifierType() and\n"
		"CVTerm.getBiologicalQualifierType().  Callers will typically want to\n"
		"use the present method to find out which one of the other two methods\n"
		"to call to find out the specific relationship.\n"
		"\n"
		"Returns the qualifier type of this object or UNKNOWN_QUALIFIER (the\n"
		"default).\n"
		"\n"
		"See also getResources(), getModelQualifierType(),\n"
		"getBiologicalQualifierType().\n"
		"\n"
		""},
	 { "CVTerm_getModelQualifierType", _wrap_CVTerm_getModelQualifierType, METH_VARARGS, "\n"
		"CVTerm_getModelQualifierType(CVTerm self) -> ModelQualifierType_t\n"
		"CVTerm_getModelQualifierType(CVTerm self) -> ModelQualifierType_t\n"
		"\n"
		"Returns the model qualifier type of this CVTerm object.\n"
		"\n"
		"The RDF element used in the SBML format for referring to external\n"
		"entities is <rdf:Description>, with a <rdf:Bag> element inside of it\n"
		"containing one or more <rdf:li> elements.  The following template\n"
		"illustrates the structure:\n"
		"\n"
		"  <rdf:Description rdf:about=\"#meta id\">\n"
		"    HISTORY\n"
		"    <RELATION_ELEMENT>\n"
		"      <rdf:Bag>\n"
		"      <rdf:li rdf:resource=\"resource URI\" />\n"
		"      ...\n"
		"      </rdf:Bag>\n"
		"    </RELATION_ELEMENT>\n"
		"    ...\n"
		"  </rdf:Description>\n"
		"\n"
		"In the template above, the placeholder meta id stands for the\n"
		"element's meta identifier, which is a field available on all SBML\n"
		"components derived from the SBase base object class.  The dotted\n"
		"portions are optional, and the ellipses ... are placeholders for zero\n"
		"or more elements of the same form as the immediately preceding\n"
		"element.\n"
		"\n"
		"The placeholder  RELATION_ELEMENT refers to a BioModels.net qualifier\n"
		"element name.  This is an element in either the XML namespace\n"
		"'http://biomodels.net/model-qualifiers' (for model qualifiers) or\n"
		"'http://biomodels.net/biology-qualifiers' (for biological qualifier).\n"
		"Callers will typically use CVTerm.getQualifierType() to find out the\n"
		"type of qualifier relevant to this particular CVTerm object, then if\n"
		"it is a model qualifier, use the present method to determine the\n"
		"specific qualifier.\n"
		"\n"
		"Annotations with model qualifiers express a relationship between an\n"
		"annotation resource and the modeling concept represented by a given\n"
		"object in the model.  The diagram below illustrates the relationship\n"
		"in this case:\n"
		"\n"
		"+---------------------+     qualifier     +---------------------+\n"
		"|    model element    +------------------>|      annotation     |\n"
		"+----------+----------+                   +---------------------+\n"
		"           |                                         |\n"
		"           | represents                              | represents\n"
		"           v                                         v\n"
		"+---------------------+    relationship   +---------------------+\n"
		"|  modelling object A +------------------>|  modelling object B |\n"
		"+---------------------+                   +---------------------+\n"
		"\n"
		"The set of known model qualifiers is, at the time of this libSBML\n"
		"release, the following:\n"
		"\n"
		"* BQM_IS\n"
		"\n"
		"* BQM_IS_DESCRIBED_BY\n"
		"\n"
		"* BQM_IS_DERIVED_FROM\n"
		"\n"
		"* BQM_IS_INSTANCE_OF\n"
		"\n"
		"* BQM_HAS_INSTANCE\n"
		"\n"
		"Any other BioModels.net qualifier found in the model is considered\n"
		"unknown by libSBML and reported as BQM_UNKNOWN.\n"
		"\n"
		"Returns the model qualifier type of this object or BQM_UNKNOWN (the\n"
		"default).\n"
		"\n"
		""},
	 { "CVTerm_getBiologicalQualifierType", _wrap_CVTerm_getBiologicalQualifierType, METH_VARARGS, "\n"
		"CVTerm_getBiologicalQualifierType(CVTerm self) -> BiolQualifierType_t\n"
		"CVTerm_getBiologicalQualifierType(CVTerm self) -> BiolQualifierType_t\n"
		"\n"
		"Returns the biological qualifier type of this CVTerm object.\n"
		"\n"
		"The RDF element used in the SBML format for referring to external\n"
		"entities is <rdf:Description>, with a <rdf:Bag> element inside of it\n"
		"containing one or more <rdf:li> elements.  The following template\n"
		"illustrates the structure:\n"
		"\n"
		"  <rdf:Description rdf:about=\"#meta id\">\n"
		"    HISTORY\n"
		"    <RELATION_ELEMENT>\n"
		"      <rdf:Bag>\n"
		"      <rdf:li rdf:resource=\"resource URI\" />\n"
		"      ...\n"
		"      </rdf:Bag>\n"
		"    </RELATION_ELEMENT>\n"
		"    ...\n"
		"  </rdf:Description>\n"
		"\n"
		"In the template above, the placeholder meta id stands for the\n"
		"element's meta identifier, which is a field available on all SBML\n"
		"components derived from the SBase base object class.  The dotted\n"
		"portions are optional, and the ellipses ... are placeholders for zero\n"
		"or more elements of the same form as the immediately preceding\n"
		"element.\n"
		"\n"
		"The placeholder  RELATION_ELEMENT refers to a BioModels.net qualifier\n"
		"element name.  This is an element in either the XML namespace\n"
		"'http://biomodels.net/model-qualifiers' (for model qualifiers) or\n"
		"'http://biomodels.net/biology-qualifiers' (for biological qualifier).\n"
		"Callers will typically use CVTerm.getQualifierType() to find out the\n"
		"type of qualifier relevant to this particular CVTerm object, then if\n"
		"it is a biological qualifier, use the present method to determine the\n"
		"specific qualifier.\n"
		"\n"
		"Annotations with biological qualifiers express a relationship between\n"
		"an annotation resource and the biological concept represented by a\n"
		"given object in the model.    The diagram below illustrates the\n"
		"relationship in this case:\n"
		"\n"
		"+---------------------+     qualifier     +---------------------+\n"
		"|    model element    +------------------>|      annotation     |\n"
		"+----------+----------+                   +---------------------+\n"
		"           |                                         |\n"
		"           | represents                              | represents\n"
		"           v                                         v\n"
		"+---------------------+    relationship   +---------------------+\n"
		"| biological entity A +------------------>| biological entity B |\n"
		"+---------------------+                   +---------------------+\n"
		"\n"
		"The set of known biological qualifiers is, at the time of this libSBML\n"
		"release, the following:\n"
		"\n"
		"* BQB_IS\n"
		"\n"
		"* BQB_HAS_PART\n"
		"\n"
		"* BQB_IS_PART_OF\n"
		"\n"
		"* BQB_IS_VERSION_OF\n"
		"\n"
		"* BQB_HAS_VERSION\n"
		"\n"
		"* BQB_IS_HOMOLOG_TO\n"
		"\n"
		"* BQB_IS_DESCRIBED_BY\n"
		"\n"
		"* BQB_IS_ENCODED_BY\n"
		"\n"
		"* BQB_ENCODES\n"
		"\n"
		"* BQB_OCCURS_IN\n"
		"\n"
		"* BQB_HAS_PROPERTY\n"
		"\n"
		"* BQB_IS_PROPERTY_OF\n"
		"\n"
		"* BQB_HAS_TAXON\n"
		"\n"
		"Any other BioModels.net qualifier found in the model is considered\n"
		"unknown by libSBML and reported as BQB_UNKNOWN.\n"
		"\n"
		"Returns the biology qualifier type of this object or BQB_UNKNOWN (the\n"
		"default).\n"
		"\n"
		""},
	 { "CVTerm_getResources", _wrap_CVTerm_getResources, METH_VARARGS, "\n"
		"CVTerm_getResources(CVTerm self) -> XMLAttributes\n"
		"CVTerm_getResources(CVTerm self) -> XMLAttributes\n"
		"\n"
		"Returns the resource references for this CVTerm object.\n"
		"\n"
		"The RDF element used in the SBML format for referring to external\n"
		"entities is <rdf:Description>, with a <rdf:Bag> element inside of it\n"
		"containing one or more <rdf:li> elements.  The following template\n"
		"illustrates the structure:\n"
		"\n"
		"  <rdf:Description rdf:about=\"#meta id\">\n"
		"    HISTORY\n"
		"    <RELATION_ELEMENT>\n"
		"      <rdf:Bag>\n"
		"      <rdf:li rdf:resource=\"resource URI\" />\n"
		"      ...\n"
		"      </rdf:Bag>\n"
		"    </RELATION_ELEMENT>\n"
		"    ...\n"
		"  </rdf:Description>\n"
		"\n"
		"In the template above, the placeholder meta id stands for the\n"
		"element's meta identifier, which is a field available on all SBML\n"
		"components derived from the SBase base object class.  The dotted\n"
		"portions are optional, and the ellipses ... are placeholders for zero\n"
		"or more elements of the same form as the immediately preceding\n"
		"element.\n"
		"\n"
		"The resource URI values shown in the template above are stored\n"
		"internally in CVTerm objects using an XMLAttributes object.  Each\n"
		"attribute stored inside the XMLAttributes will have the same name\n"
		"(specifically, \"rdf:resource\") but a different value, and the value\n"
		"will be a  resource URI shown in the XML template above.\n"
		"\n"
		"A valid CVTerm entity must always have at least one resource and a\n"
		"value for the relationship qualifier.\n"
		"\n"
		"Returns the XMLAttributes that store the resources of this CVTerm.\n"
		"\n"
		"See also getQualifierType(), addResource(), getResourceURI().\n"
		"\n"
		""},
	 { "CVTerm_getNumResources", _wrap_CVTerm_getNumResources, METH_VARARGS, "\n"
		"CVTerm_getNumResources(CVTerm self) -> unsigned int\n"
		"CVTerm_getNumResources(CVTerm self) -> unsigned int\n"
		"\n"
		"Returns the number of resources for this CVTerm object.\n"
		"\n"
		"The RDF element used in the SBML format for referring to external\n"
		"entities is <rdf:Description>, with a <rdf:Bag> element inside of it\n"
		"containing one or more <rdf:li> elements.  The following template\n"
		"illustrates the structure:\n"
		"\n"
		"  <rdf:Description rdf:about=\"#meta id\">\n"
		"    HISTORY\n"
		"    <RELATION_ELEMENT>\n"
		"      <rdf:Bag>\n"
		"      <rdf:li rdf:resource=\"resource URI\" />\n"
		"      ...\n"
		"      </rdf:Bag>\n"
		"    </RELATION_ELEMENT>\n"
		"    ...\n"
		"  </rdf:Description>\n"
		"\n"
		"In the template above, the placeholder meta id stands for the\n"
		"element's meta identifier, which is a field available on all SBML\n"
		"components derived from the SBase base object class.  The dotted\n"
		"portions are optional, and the ellipses ... are placeholders for zero\n"
		"or more elements of the same form as the immediately preceding\n"
		"element.\n"
		"\n"
		"The fragment above illustrates that there can be more than one\n"
		"resource referenced by a given relationship annotation (i.e., the\n"
		"resource URI values associated with a particular RELATION_ELEMENT).\n"
		"The present method returns a count of the resources stored in this\n"
		"CVTerm object.\n"
		"\n"
		"Returns the number of resources in the set of XMLAttributes of this\n"
		"CVTerm.\n"
		"\n"
		"See also getResources(), getResourceURI().\n"
		"\n"
		""},
	 { "CVTerm_getResourceURI", _wrap_CVTerm_getResourceURI, METH_VARARGS, "\n"
		"CVTerm_getResourceURI(CVTerm self, unsigned int n) -> string\n"
		"CVTerm_getResourceURI(CVTerm self, unsigned int n) -> string\n"
		"\n"
		"Returns the value of the nth resource for this CVTerm object.\n"
		"\n"
		"The RDF element used in the SBML format for referring to external\n"
		"entities is <rdf:Description>, with a <rdf:Bag> element inside of it\n"
		"containing one or more <rdf:li> elements.  The following template\n"
		"illustrates the structure:\n"
		"\n"
		"  <rdf:Description rdf:about=\"#meta id\">\n"
		"    HISTORY\n"
		"    <RELATION_ELEMENT>\n"
		"      <rdf:Bag>\n"
		"      <rdf:li rdf:resource=\"resource URI\" />\n"
		"      ...\n"
		"      </rdf:Bag>\n"
		"    </RELATION_ELEMENT>\n"
		"    ...\n"
		"  </rdf:Description>\n"
		"\n"
		"In the template above, the placeholder meta id stands for the\n"
		"element's meta identifier, which is a field available on all SBML\n"
		"components derived from the SBase base object class.  The dotted\n"
		"portions are optional, and the ellipses ... are placeholders for zero\n"
		"or more elements of the same form as the immediately preceding\n"
		"element.\n"
		"\n"
		"The fragment above illustrates that there can be more than one\n"
		"resource referenced by a given relationship annotation (i.e., the\n"
		"resource URI values associated with a particular RELATION_ELEMENT).\n"
		"LibSBML stores all resource URIs in a single CVTerm object for a given\n"
		"relationship. Callers can use CVTerm.getNumResources() to find out how\n"
		"many resources are stored in this CVTerm object, then call this method\n"
		"to retrieve the nth resource URI.\n"
		"\n"
		"Parameter 'n' is the index of the resource to query.\n"
		"\n"
		"Returns string representing the value of the nth resource in the set\n"
		"of XMLAttributes of this CVTerm.\n"
		"\n"
		"See also getNumResources(), getQualifierType().\n"
		"\n"
		""},
	 { "CVTerm_setQualifierType", _wrap_CVTerm_setQualifierType, METH_VARARGS, "\n"
		"CVTerm_setQualifierType(CVTerm self, QualifierType_t type) -> int\n"
		"\n"
		"Sets the qualifier code of this CVTerm object.\n"
		"\n"
		"Parameter 'type' is the qualifier type.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also getQualifierType().\n"
		"\n"
		""},
	 { "CVTerm_setModelQualifierType", _wrap_CVTerm_setModelQualifierType, METH_VARARGS, "\n"
		"CVTerm_setModelQualifierType(CVTerm self, ModelQualifierType_t type) -> int\n"
		"CVTerm_setModelQualifierType(CVTerm self, string qualifier) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setModelQualifierType(string qualifier)\n"
		"\n"
		"Sets the model qualifier type value of this CVTerm object.\n"
		"\n"
		"Parameter 'qualifier' is the string representing a model qualifier.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: If the Qualifier Type of this object is not MODEL_QUALIFIER,\n"
		"then the model qualifier type will default to BQM_UNKNOWN.\n"
		"\n"
		"See also getQualifierType(), setQualifierType().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setModelQualifierType(ModelQualifierType_t type)\n"
		"\n"
		"Sets the model qualifier type of this CVTerm object.\n"
		"\n"
		"Parameter 'type' is the model qualifier type.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: If the qualifier type of this object is not MODEL_QUALIFIER,\n"
		"then the then the model qualifier type will default to BQM_UNKNOWN.\n"
		"\n"
		"See also getQualifierType(), setQualifierType().\n"
		"\n"
		""},
	 { "CVTerm_setBiologicalQualifierType", _wrap_CVTerm_setBiologicalQualifierType, METH_VARARGS, "\n"
		"CVTerm_setBiologicalQualifierType(CVTerm self, BiolQualifierType_t type) -> int\n"
		"CVTerm_setBiologicalQualifierType(CVTerm self, string qualifier) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setBiologicalQualifierType(string qualifier)\n"
		"\n"
		"Sets the biology qualifier type code of this CVTerm object.\n"
		"\n"
		"Parameter 'qualifier' is the string representing a biology qualifier.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: If the Qualifier Type of this object is not\n"
		"BIOLOGICAL_QUALIFIER, then the biology qualifier type code will\n"
		"default to BQB_UNKNOWN.\n"
		"\n"
		"See also getQualifierType(), setQualifierType().\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setBiologicalQualifierType(BiolQualifierType_t type)\n"
		"\n"
		"Sets the biology qualifier type of this CVTerm object.\n"
		"\n"
		"Parameter 'type' is the biology qualifier type.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: If the Qualifier Type of this object is not\n"
		"BIOLOGICAL_QUALIFIER, then the biology qualifier type will default to\n"
		"BQB_UNKNOWN.\n"
		"\n"
		"See also getQualifierType(), setQualifierType().\n"
		"\n"
		""},
	 { "CVTerm_addResource", _wrap_CVTerm_addResource, METH_VARARGS, "\n"
		"CVTerm_addResource(CVTerm self, string resource) -> int\n"
		"\n"
		"Adds a resource reference to this CVTerm object.\n"
		"\n"
		"The SBML Level 2 and Level 3 specifications define a simple format\n"
		"for annotating models when (a) referring to controlled vocabulary\n"
		"terms and database identifiers that define and describe biological and\n"
		"other entities, and (b) describing the creator of a model and the\n"
		"model's modification history.  The annotation content is stored in\n"
		"<annotation> elements attached to individual SBML elements.  The\n"
		"format for storing the content inside SBML <annotation> elements is a\n"
		"subset of W3C RDF (Resource Description Format) expressed in XML.  The\n"
		"CVTerm class provides a programming interface for working directly\n"
		"with controlled vocabulary term ('CV term') objects without having to\n"
		"deal directly with the XML form. When libSBML reads in an SBML model\n"
		"containing RDF annotations, it parses those annotations into a list of\n"
		"CVTerm objects, and when writing a model, it parses the CVTerm objects\n"
		"back into the appropriate SBML <annotation> structure.\n"
		"\n"
		"The specific RDF element used in this SBML format for referring to\n"
		"external entities is <rdf:Description>, with a <rdf:Bag> element\n"
		"containing one or more <rdf:li> elements.  Each such element refers to\n"
		"a data item in an external resource; the resource and data item are\n"
		"together identified uniquely using a URI.  The following template\n"
		"illustrates the structure:\n"
		"\n"
		"     <rdf:Description rdf:about=\"#meta id\">\n"
		"       HISTORY\n"
		"       <RELATION_ELEMENT>\n"
		"         <rdf:Bag>\n"
		"           <rdf:li rdf:resource=\"resource URI\" />\n"
		"           ...\n"
		"         </rdf:Bag>\n"
		"       </RELATION_ELEMENT>\n"
		"       ...\n"
		"     </rdf:Description>\n"
		"\n"
		"In the template above, the placeholder meta id stands for the\n"
		"element's meta identifier, which is a field available on all SBML\n"
		"components derived from the SBase base object class.  The dotted\n"
		"portions are optional, and the ellipses ... are placeholders for zero\n"
		"or more elements of the same form as the immediately preceding\n"
		"element. The placeholder  RELATION_ELEMENT refers to a BioModels.net\n"
		"qualifier element name.  This is an element in either the XML\n"
		"namespace 'http://biomodels.net/model-qualifiers' (for model\n"
		"qualifiers) or 'http://biomodels.net/biology-qualifiers' (for\n"
		"biological qualifier).\n"
		"\n"
		"The resource URI is a required data value that uniquely identifies a\n"
		"resource and data within that resource to which the annotation refers.\n"
		"The present method allows callers to add a reference to a resource URI\n"
		"with the same relationship to the enclosing SBML object.  (In other\n"
		"words, the argument to this method is a resource URI as shown in the\n"
		"XML fragment above.)  Resources are stored in this CVTerm object\n"
		"within an XMLAttributes object.\n"
		"\n"
		"The relationship of this CVTerm to the enclosing SBML object can be\n"
		"determined using the CVTerm methods such as\n"
		"CVTerm.getModelQualifierType() and\n"
		"CVTerm.getBiologicalQualifierType().\n"
		"\n"
		"Parameter 'resource' is a string representing the URI of the resource\n"
		"and data item being referenced; e.g.,\n"
		"'http://www.geneontology.org/#GO:0005892'.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also getResources(), removeResource(), getQualifierType(),\n"
		"getModelQualifierType(), getBiologicalQualifierType().\n"
		"\n"
		""},
	 { "CVTerm_removeResource", _wrap_CVTerm_removeResource, METH_VARARGS, "\n"
		"CVTerm_removeResource(CVTerm self, string resource) -> int\n"
		"\n"
		"Removes a resource URI from the set of resources stored in this CVTerm\n"
		"object.\n"
		"\n"
		"Parameter 'resource' is a string representing the resource URI to\n"
		"remove; e.g., 'http://www.geneontology.org/#GO:0005892'.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"See also addResource().\n"
		"\n"
		""},
	 { "CVTerm_hasBeenModified", _wrap_CVTerm_hasBeenModified, METH_O, "\n"
		"CVTerm_hasBeenModified(CVTerm self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "CVTerm_resetModifiedFlags", _wrap_CVTerm_resetModifiedFlags, METH_O, "\n"
		"CVTerm_resetModifiedFlags(CVTerm self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "CVTerm_hasRequiredAttributes", _wrap_CVTerm_hasRequiredAttributes, METH_VARARGS, "\n"
		"CVTerm_hasRequiredAttributes(CVTerm self) -> bool\n"
		"CVTerm_hasRequiredAttributes(CVTerm self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this\n"
		"CVTerm object have been set.\n"
		"\n"
		"Note: The required attributes for a CVTerm are:\n"
		"\n"
		"* a qualifier type, which can be either a model qualifier or a\n"
		"biological qualifier\n"
		"\n"
		"* at least one resource\n"
		"\n"
		""},
	 { "CVTerm_getNumNestedCVTerms", _wrap_CVTerm_getNumNestedCVTerms, METH_O, "\n"
		"CVTerm_getNumNestedCVTerms(CVTerm self) -> unsigned int\n"
		"\n"
		"Returns the number of CVTerm objects nested within this CVTerm object.\n"
		"\n"
		"Returns the number of CVTerms nested within this CVTerm object.\n"
		"\n"
		"Note: this does not recurse through potentially nested CVTerm objects\n"
		"within a given nested CVTerm. It returns the number of terms\n"
		"immediately nested within this CVTerm.\n"
		"\n"
		""},
	 { "CVTerm_getNestedCVTerm", _wrap_CVTerm_getNestedCVTerm, METH_VARARGS, "\n"
		"CVTerm_getNestedCVTerm(CVTerm self, unsigned int n) -> CVTerm\n"
		"CVTerm_getNestedCVTerm(CVTerm self, unsigned int n) -> CVTerm\n"
		"\n"
		"Returns the nth CVTerm in the list of CVTerms of this CVTerm object.\n"
		"\n"
		"Parameter 'n' is long the index of the CVTerm to retrieve.\n"
		"\n"
		"Returns the nth CVTerm in the list of CVTerms for this CVTerm object\n"
		"or 'None' if no such object exists.\n"
		"\n"
		""},
	 { "CVTerm_getListNestedCVTerms", _wrap_CVTerm_getListNestedCVTerms, METH_VARARGS, "\n"
		"CVTerm_getListNestedCVTerms(CVTerm self) -> List\n"
		"CVTerm_getListNestedCVTerms(CVTerm self) -> List const *\n"
		"\n"
		"Returns a list of CVTerm objects contained within this CVTerm object.\n"
		"\n"
		"Returns the list of CVTerms for this CVTerm object.\n"
		"\n"
		""},
	 { "CVTerm_addNestedCVTerm", _wrap_CVTerm_addNestedCVTerm, METH_VARARGS, "\n"
		"CVTerm_addNestedCVTerm(CVTerm self, CVTerm term) -> int\n"
		"\n"
		"Adds a copy of the given CVTerm object to the list of nested CVTerm\n"
		"objects within this CVTerm object.\n"
		"\n"
		"Parameter 'term' is the CVTerm to assign.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "CVTerm_removeNestedCVTerm", _wrap_CVTerm_removeNestedCVTerm, METH_VARARGS, "\n"
		"CVTerm_removeNestedCVTerm(CVTerm self, unsigned int n) -> CVTerm\n"
		"\n"
		"Removes the nth CVTerm in the list of CVTerms of this CVTerm object\n"
		"and returns a pointer to it.\n"
		"\n"
		"Parameter 'n' is long the index of the CVTerm to retrieve.\n"
		"\n"
		"Returns a pointer to the nth CVTerm in the list of CVTerms for this\n"
		"CVTerm object.\n"
		"\n"
		""},
	 { "CVTerm_swigregister", CVTerm_swigregister, METH_O, NULL},
	 { "CVTerm_swiginit", CVTerm_swiginit, METH_VARARGS, NULL},
	 { "ModelQualifierType_toString", _wrap_ModelQualifierType_toString, METH_O, "\n"
		"ModelQualifierType_toString(ModelQualifierType_t type) -> char const *\n"
		"\n"
		"This method takes a model qualifier type code and returns a string\n"
		"representing the code.\n"
		"\n"
		"This method takes a model qualifier type as argument and returns a\n"
		"string name corresponding to that code.  For example, passing it the\n"
		"qualifier BQM_IS_DESCRIBED_BY will return the string 'isDescribedBy'.\n"
		"\n"
		"Parameter 'type' is the  value to translate. The value should be a\n"
		"libSBML constant whose name begins with 'BQM_,' such as (for example)\n"
		"BQM_IS.\n"
		"\n"
		"Returns a human readable qualifier name for the given qualifier type.\n"
		"\n"
		"Note: The caller does not own the returned string and is therefore not\n"
		"allowed to modify it.\n"
		"\n"
		""},
	 { "BiolQualifierType_toString", _wrap_BiolQualifierType_toString, METH_O, "\n"
		"BiolQualifierType_toString(BiolQualifierType_t type) -> char const *\n"
		"\n"
		"This method takes a biol qualifier type code and returns a string\n"
		"representing the code.\n"
		"\n"
		"This method takes a biol qualifier type as argument and returns a\n"
		"string name corresponding to that code.  For example, passing it the\n"
		"qualifier BQB_HAS_VERSION will return the string 'hasVersion'.\n"
		"\n"
		"Parameter 'type' is the  value to translate. The value should be a\n"
		"constant whose name begins with 'BQB_,' such as (for example) BQB_IS.\n"
		"\n"
		"Returns a human readable qualifier name for the given type.\n"
		"\n"
		"Note: The caller does not own the returned string and is therefore not\n"
		"allowed to modify it.\n"
		"\n"
		""},
	 { "ModelQualifierType_fromString", _wrap_ModelQualifierType_fromString, METH_O, "\n"
		"ModelQualifierType_fromString(char const * s) -> ModelQualifierType_t\n"
		"\n"
		"This method takes a string and returns a model qualifier representing\n"
		"the string.\n"
		"\n"
		"This method takes a string as argument and returns a model qualifier\n"
		"type corresponding to that string.  For example, passing it the string\n"
		"'isDescribedBy' will return the qualifier BQM_IS_DESCRIBED_BY.\n"
		"\n"
		"Parameter 's' is the string to translate to a libSBML constant value\n"
		"representing a model qualifier.\n"
		"\n"
		"Returns a libSBML qualifier enumeration value for the given human\n"
		"readable qualifier name.\n"
		"\n"
		""},
	 { "BiolQualifierType_fromString", _wrap_BiolQualifierType_fromString, METH_O, "\n"
		"BiolQualifierType_fromString(char const * s) -> BiolQualifierType_t\n"
		"\n"
		"This method takes a string and returns a biol qualifier representing\n"
		"the string.\n"
		"\n"
		"This method takes a string as argument and returns a biol qualifier\n"
		"type corresponding to that string.  For example, passing it the string\n"
		"'hasVersion' will return the qualifier BQB_HAS_VERSION.\n"
		"\n"
		"Parameter 's' is the string to translate to a libSBML constant value\n"
		"representing a biological qualifier.\n"
		"\n"
		"Returns a libSBML qualifier enumeration value for the given human\n"
		"readable qualifier name.\n"
		"\n"
		""},
	 { "delete_Date", _wrap_delete_Date, METH_O, "delete_Date(Date self)"},
	 { "new_Date", _wrap_new_Date, METH_VARARGS, "\n"
		"Date(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)\n"
		"Date(string date)\n"
		"new_Date(Date orig) -> Date\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Date(string date)\n"
		"\n"
		"Creates a Date object from a string expressing a date and time value.\n"
		"\n"
		"This constructor expects its argument to be in the W3C date format\n"
		"with time zone offset, used in RDF Dublin Core annotations within\n"
		"SBML.\n"
		"\n"
		"The date format expresses a date and time value as a string of the\n"
		"form YYYY-MM-DDThh:mm:ssXHH:ZZ, where\n"
		"\n"
		"* YYYY is a four-digit integer representing the year.  This should\n"
		"be a four-digit number such as '2011.'\n"
		"\n"
		"* MM is a two-digit integer representing the month, with a range\n"
		"of values of 01-12.  The value '1' represents January, and so on.\n"
		"\n"
		"* DD is a two-digit integer representing the day of the month,\n"
		"with a range of values of 01-31.\n"
		"\n"
		"* T is the literal character 'T.'\n"
		"\n"
		"* hh is a two-digit integer representing the hour on a 24-hour\n"
		"clock, with a range of values of 00-23.\n"
		"\n"
		"* mm is a two-digit integer representing the minute, with a range\n"
		"of 00-59.\n"
		"\n"
		"* ss is a two-digit integer representing the second, with a range\n"
		"of 0-59.\n"
		"\n"
		"* X is the the sign of the time zone offset, either '+' or -.\n"
		"\n"
		"* HH is a two-digit integer representing the hour of the time zone\n"
		"offset, with a range of 00-23.\n"
		"\n"
		"* ZZ is a two-digit integer representing the minutes of the time\n"
		"zone offset, with a range of 00-59.\n"
		"\n"
		"In the string format above, it is important not to forget the literal\n"
		"character 'T' in the string.  Here is an example date/time string:\n"
		"1997-07-16T19:20:30+01:00, which would represent July 16, 1997, at\n"
		"19:20:30 in Central European Time (which is UTC +1:00).\n"
		"\n"
		"If this constructor is given a 'None' argument or a string of length\n"
		"zero, it constructs a Date object with the value of January 1, 2000,\n"
		"at time 00:00 UTC.  Otherwise, the argument must be in the complete\n"
		"format described above, or unpredictable results will happen.\n"
		"\n"
		"Parameter 'date' is a string representing the date.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Date(long year = 2000, long month = 1, long day = 1, long\n"
		"hour = 0, long minute = 0, long second = 0, long sign = 0, long\n"
		"hoursOffset = 0, long minutesOffset = 0)\n"
		"\n"
		"Creates a time and date representation for use in model annotations\n"
		"and elsewhere.\n"
		"\n"
		"The following is the complete set of possible arguments to this\n"
		"constructor, with default values as indicated:\n"
		"\n"
		"Parameter 'year' is a long integereger representing the year.  This\n"
		"should be a four-digit number such as '2011.'  (Default value used if\n"
		"this argument is not given: '2000.)'\n"
		"\n"
		"Parameter 'month' is a long integereger representing the month, with a\n"
		"range of values of 1-12.  The value '1' represents January, and so on.\n"
		"(Default value used if this argument is not given: '1.)'\n"
		"\n"
		"Parameter 'day' is a long integereger representing the day of the\n"
		"month, with a range of values of 1-31.  (Default value used if this\n"
		"argument is not given: '1.)'\n"
		"\n"
		"Parameter 'hour' is a long integereger representing the hour on a\n"
		"24-hour clock, with a range of values of 0-23.  (Default value used if\n"
		"this argument is not given: '0.)'\n"
		"\n"
		"Parameter 'minute' is a long integereger representing the minute, with\n"
		"a range of 0-59.  (Default value used if this argument is not given:\n"
		"'0.)'\n"
		"\n"
		"Parameter 'second' is a long integereger representing the second, with\n"
		"a range of 0-59.  (Default value used if this argument is not given:\n"
		"'0.)'\n"
		"\n"
		"Parameter 'sign' is a long integereger representing the sign of the\n"
		"offset ('0' signifying '+' and '1' signifying '-).'  See the paragraph\n"
		"below for further explanations.  (Default value used if this argument\n"
		"is not given: '0.)'\n"
		"\n"
		"Parameter 'hoursOffset' is a long integereger representing the time\n"
		"zone's hour offset from GMT.  (Default value used if this argument is\n"
		"not given: '0.)'\n"
		"\n"
		"Parameter 'minutesOffset' is a long integereger representing the time\n"
		"zone's minute offset from GMT.  (Default value used if this argument\n"
		"is not given: '0.)'\n"
		"\n"
		"To illustrate the time zone offset, a value of -05:00 would correspond\n"
		"to USA Eastern Standard Time.  In the Date object, this would require\n"
		"a value of '1' for the sign field, '5' for the hour offset and '0' for\n"
		"the minutes offset.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    Date(Date orig)\n"
		"\n"
		"Copy constructor; creates a copy of this Date.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "Date_clone", _wrap_Date_clone, METH_O, "\n"
		"Date_clone(Date self) -> Date\n"
		"\n"
		"Creates and returns a deep copy of this Date object.\n"
		"\n"
		"Returns the (deep) copy of this Date object.\n"
		"\n"
		""},
	 { "Date_getYear", _wrap_Date_getYear, METH_O, "\n"
		"Date_getYear(Date self) -> unsigned int\n"
		"\n"
		"Returns the year from this Date.\n"
		"\n"
		"Returns the year from this Date.\n"
		"\n"
		""},
	 { "Date_getMonth", _wrap_Date_getMonth, METH_O, "\n"
		"Date_getMonth(Date self) -> unsigned int\n"
		"\n"
		"Returns the month from this Date.\n"
		"\n"
		"Returns the month from this Date.\n"
		"\n"
		""},
	 { "Date_getDay", _wrap_Date_getDay, METH_O, "\n"
		"Date_getDay(Date self) -> unsigned int\n"
		"\n"
		"Returns the day from this Date.\n"
		"\n"
		"Returns the day from this Date.\n"
		"\n"
		""},
	 { "Date_getHour", _wrap_Date_getHour, METH_O, "\n"
		"Date_getHour(Date self) -> unsigned int\n"
		"\n"
		"Returns the hour from this Date.\n"
		"\n"
		"Returns the hour from this Date.\n"
		"\n"
		""},
	 { "Date_getMinute", _wrap_Date_getMinute, METH_O, "\n"
		"Date_getMinute(Date self) -> unsigned int\n"
		"\n"
		"Returns the minute from this Date.\n"
		"\n"
		"Returns the minute from this Date.\n"
		"\n"
		""},
	 { "Date_getSecond", _wrap_Date_getSecond, METH_O, "\n"
		"Date_getSecond(Date self) -> unsigned int\n"
		"\n"
		"Returns the seconds from this Date.\n"
		"\n"
		"Returns the seconds from this Date.\n"
		"\n"
		""},
	 { "Date_getSignOffset", _wrap_Date_getSignOffset, METH_O, "\n"
		"Date_getSignOffset(Date self) -> unsigned int\n"
		"\n"
		"Returns the sign of the time zone offset from this Date.\n"
		"\n"
		"Returns the sign of the offset from this Date.\n"
		"\n"
		""},
	 { "Date_getHoursOffset", _wrap_Date_getHoursOffset, METH_O, "\n"
		"Date_getHoursOffset(Date self) -> unsigned int\n"
		"\n"
		"Returns the hours of the time zone offset from this Date.\n"
		"\n"
		"Returns the hours of the offset from this Date.\n"
		"\n"
		""},
	 { "Date_getMinutesOffset", _wrap_Date_getMinutesOffset, METH_O, "\n"
		"Date_getMinutesOffset(Date self) -> unsigned int\n"
		"\n"
		"Returns the minutes of the time zone offset from this Date.\n"
		"\n"
		"Returns the minutes of the offset from this Date.\n"
		"\n"
		""},
	 { "Date_getDateAsString", _wrap_Date_getDateAsString, METH_O, "\n"
		"Date_getDateAsString(Date self) -> string\n"
		"\n"
		"Returns the current Date value in text-string form.\n"
		"\n"
		"The string returned will be in the W3C date format with time zone\n"
		"offset, used in RDF Dublin Core annotations within SBML.\n"
		"\n"
		"The date format expresses a date and time value as a string of the\n"
		"form YYYY-MM-DDThh:mm:ssXHH:ZZ, where\n"
		"\n"
		"* YYYY is a four-digit integer representing the year.  This should\n"
		"be a four-digit number such as '2011.'\n"
		"\n"
		"* MM is a two-digit integer representing the month, with a range\n"
		"of values of 01-12.  The value '1' represents January, and so on.\n"
		"\n"
		"* DD is a two-digit integer representing the day of the month,\n"
		"with a range of values of 01-31.\n"
		"\n"
		"* T is the literal character 'T.'\n"
		"\n"
		"* hh is a two-digit integer representing the hour on a 24-hour\n"
		"clock, with a range of values of 00-23.\n"
		"\n"
		"* mm is a two-digit integer representing the minute, with a range\n"
		"of 00-59.\n"
		"\n"
		"* ss is a two-digit integer representing the second, with a range\n"
		"of 0-59.\n"
		"\n"
		"* X is the the sign of the time zone offset, either '+' or -.\n"
		"\n"
		"* HH is a two-digit integer representing the hour of the time zone\n"
		"offset, with a range of 00-23.\n"
		"\n"
		"* ZZ is a two-digit integer representing the minutes of the time\n"
		"zone offset, with a range of 00-59.\n"
		"\n"
		"In the string format above, it is important not to forget the literal\n"
		"character 'T' in the string.  Here is an example date/time string:\n"
		"1997-07-16T19:20:30+01:00, which would represent July 16, 1997, at\n"
		"19:20:30 in Central European Time (which is UTC +1:00).\n"
		"\n"
		"Returns the date as a string.\n"
		"\n"
		""},
	 { "Date_setYear", _wrap_Date_setYear, METH_VARARGS, "\n"
		"Date_setYear(Date self, unsigned int year) -> int\n"
		"\n"
		"Sets the value of the year of this Date object.\n"
		"\n"
		"The value given as argument must be between 1000 and 9999 inclusive.\n"
		"(In the millennium during which this libSBML documentation is being\n"
		"written, a typical value is '2011,' but we hope that SBML will\n"
		"continue to be used for a long time.)\n"
		"\n"
		"Parameter 'year' is a long integer representing the year.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Date_setMonth", _wrap_Date_setMonth, METH_VARARGS, "\n"
		"Date_setMonth(Date self, unsigned int month) -> int\n"
		"\n"
		"Sets the value of the month of this Date object.\n"
		"\n"
		"Parameter 'month' is a long integer representing the month; it must be\n"
		"in the range 1-12 or an error will be signaled.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Date_setDay", _wrap_Date_setDay, METH_VARARGS, "\n"
		"Date_setDay(Date self, unsigned int day) -> int\n"
		"\n"
		"Sets the value of the day of this Date object.\n"
		"\n"
		"Parameter 'day' is a long integer representing the day; it must be in\n"
		"the range 0-31 or an error will be signaled.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Date_setHour", _wrap_Date_setHour, METH_VARARGS, "\n"
		"Date_setHour(Date self, unsigned int hour) -> int\n"
		"\n"
		"Sets the value of the hour of this Date object.\n"
		"\n"
		"Parameter 'hour' is a long integer representing the hour to set; it\n"
		"must be in the range 0-23 or an error will be signaled.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Date_setMinute", _wrap_Date_setMinute, METH_VARARGS, "\n"
		"Date_setMinute(Date self, unsigned int minute) -> int\n"
		"\n"
		"Sets the value of the minute of this Date object.\n"
		"\n"
		"Parameter 'minute' is a long integer representing the minute to set;\n"
		"it must be in the range 0-59 or an error will be signaled.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Date_setSecond", _wrap_Date_setSecond, METH_VARARGS, "\n"
		"Date_setSecond(Date self, unsigned int second) -> int\n"
		"\n"
		"Sets the value of the second of the Date object.\n"
		"\n"
		"Parameter 'second' is a long integer representing the seconds; it must\n"
		"be in the range 0-59 or an error will be signaled.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Date_setSignOffset", _wrap_Date_setSignOffset, METH_VARARGS, "\n"
		"Date_setSignOffset(Date self, unsigned int sign) -> int\n"
		"\n"
		"Sets the value of the sign of the time zone offset of this Date\n"
		"object.\n"
		"\n"
		"The only permissible values are '0' and '1.'\n"
		"\n"
		"Parameter 'sign' is a long integer representing the sign of the\n"
		"offset, with '0' signifying '+' and '1' signifying '-.'\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Date_setHoursOffset", _wrap_Date_setHoursOffset, METH_VARARGS, "\n"
		"Date_setHoursOffset(Date self, unsigned int hoursOffset) -> int\n"
		"\n"
		"Sets the value of this Date object's time zone hour offset.\n"
		"\n"
		"Parameter 'hoursOffset' is a long integer representing the hours of\n"
		"the offset; it must be in the range 0-12 or an error will be signaled.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Date_setMinutesOffset", _wrap_Date_setMinutesOffset, METH_VARARGS, "\n"
		"Date_setMinutesOffset(Date self, unsigned int minutesOffset) -> int\n"
		"\n"
		"Sets the value of this Date object's time zone minutes offset.\n"
		"\n"
		"Parameter 'minutesOffset' is a long integer representing the minutes\n"
		"of the offset; it must be in the range 0-59 or an error will be\n"
		"signaled.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Date_setDateAsString", _wrap_Date_setDateAsString, METH_VARARGS, "\n"
		"Date_setDateAsString(Date self, string date) -> int\n"
		"\n"
		"Sets the value of this Date object using a date and time value\n"
		"expressed as a text string.\n"
		"\n"
		"This method expects its argument to be in the W3C date format with\n"
		"time zone offset, used in RDF Dublin Core annotations within SBML.\n"
		"\n"
		"The date format expresses a date and time value as a string of the\n"
		"form YYYY-MM-DDThh:mm:ssXHH:ZZ, where\n"
		"\n"
		"* YYYY is a four-digit integer representing the year.  This should\n"
		"be a four-digit number such as '2011.'\n"
		"\n"
		"* MM is a two-digit integer representing the month, with a range\n"
		"of values of 01-12.  The value '1' represents January, and so on.\n"
		"\n"
		"* DD is a two-digit integer representing the day of the month,\n"
		"with a range of values of 01-31.\n"
		"\n"
		"* T is the literal character 'T.'\n"
		"\n"
		"* hh is a two-digit integer representing the hour on a 24-hour\n"
		"clock, with a range of values of 00-23.\n"
		"\n"
		"* mm is a two-digit integer representing the minute, with a range\n"
		"of 00-59.\n"
		"\n"
		"* ss is a two-digit integer representing the second, with a range\n"
		"of 0-59.\n"
		"\n"
		"* X is the the sign of the time zone offset, either '+' or -.\n"
		"\n"
		"* HH is a two-digit integer representing the hour of the time zone\n"
		"offset, with a range of 00-23.\n"
		"\n"
		"* ZZ is a two-digit integer representing the minutes of the time\n"
		"zone offset, with a range of 00-59.\n"
		"\n"
		"In the string format above, it is important not to forget the literal\n"
		"character 'T' in the string.  Here is an example date/time string:\n"
		"1997-07-16T19:20:30+01:00, which would represent July 16, 1997, at\n"
		"19:20:30 in Central European Time (which is UTC +1:00).\n"
		"\n"
		"If this method is given a 'None' argument or a string of length zero,\n"
		"it constructs a Date object with the value of January 1, 2000, at time\n"
		"00:00 UTC.  Otherwise, the argument must be in the complete format\n"
		"described above, or unpredictable results will happen.\n"
		"\n"
		"Parameter 'date' is a string representing the date.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "Date_representsValidDate", _wrap_Date_representsValidDate, METH_O, "\n"
		"Date_representsValidDate(Date self) -> bool\n"
		"\n"
		"Returns 'True' or 'False' depending on whether this date object\n"
		"represents a valid date and time value.\n"
		"\n"
		"This method verifies that the date/time value stored in this object is\n"
		"well-formed and represents plausible values.  A time and date value in\n"
		"the W3C format takes the form YYYY-MM-DDThh:mm:ssXHH:ZZ (e.g.,\n"
		"1997-07-16T19:20:30+01:00) where XHH:ZZ is the time zone offset.  This\n"
		"method checks such things as whether the value of the month number is\n"
		"less than or equal to 12, whether the value of the minutes number is\n"
		"less than or equal to 59, whether a time zone offset is set, etc.\n"
		"\n"
		"Returns 'True' if the date is valid, 'False' otherwise.\n"
		"\n"
		""},
	 { "Date_hasBeenModified", _wrap_Date_hasBeenModified, METH_O, "\n"
		"Date_hasBeenModified(Date self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Date_resetModifiedFlags", _wrap_Date_resetModifiedFlags, METH_O, "\n"
		"Date_resetModifiedFlags(Date self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "Date_swigregister", Date_swigregister, METH_O, NULL},
	 { "Date_swiginit", Date_swiginit, METH_VARARGS, NULL},
	 { "delete_ModelCreator", _wrap_delete_ModelCreator, METH_O, "delete_ModelCreator(ModelCreator self)"},
	 { "new_ModelCreator", _wrap_new_ModelCreator, METH_VARARGS, "\n"
		"ModelCreator()\n"
		"ModelCreator(XMLNode creator)\n"
		"new_ModelCreator(ModelCreator orig) -> ModelCreator\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ModelCreator( XMLNode creator)\n"
		"\n"
		"Creates a new ModelCreator from an XMLNode.\n"
		"\n"
		"Parameter 'creator' is the XMLNode from which to create the\n"
		"ModelCreator.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ModelCreator()\n"
		"\n"
		"Creates a new ModelCreator object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ModelCreator(ModelCreator orig)\n"
		"\n"
		"Copy constructor; creates a copy of the ModelCreator.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		""},
	 { "ModelCreator_clone", _wrap_ModelCreator_clone, METH_O, "\n"
		"ModelCreator_clone(ModelCreator self) -> ModelCreator\n"
		"\n"
		"Creates and returns a deep copy of this ModelCreator object.\n"
		"\n"
		"Returns the (deep) copy of this ModelCreator object.\n"
		"\n"
		""},
	 { "ModelCreator_getFamilyName", _wrap_ModelCreator_getFamilyName, METH_O, "\n"
		"ModelCreator_getFamilyName(ModelCreator self) -> string\n"
		"\n"
		"Returns the 'family name' stored in this ModelCreator object.\n"
		"\n"
		"Returns the 'family name' portion of the ModelCreator object.\n"
		"\n"
		""},
	 { "ModelCreator_getGivenName", _wrap_ModelCreator_getGivenName, METH_O, "\n"
		"ModelCreator_getGivenName(ModelCreator self) -> string\n"
		"\n"
		"Returns the 'given name' stored in this ModelCreator object.\n"
		"\n"
		"Returns the 'given name' portion of the ModelCreator object.\n"
		"\n"
		""},
	 { "ModelCreator_getEmail", _wrap_ModelCreator_getEmail, METH_O, "\n"
		"ModelCreator_getEmail(ModelCreator self) -> string\n"
		"\n"
		"Returns the 'email' stored in this ModelCreator object.\n"
		"\n"
		"Returns email from the ModelCreator.\n"
		"\n"
		""},
	 { "ModelCreator_getOrganization", _wrap_ModelCreator_getOrganization, METH_O, "\n"
		"ModelCreator_getOrganization(ModelCreator self) -> string\n"
		"\n"
		"Returns the 'organization' stored in this ModelCreator object.\n"
		"\n"
		"Returns organization from the ModelCreator.\n"
		"\n"
		""},
	 { "ModelCreator_getOrganisation", _wrap_ModelCreator_getOrganisation, METH_O, "\n"
		"ModelCreator_getOrganisation(ModelCreator self) -> string\n"
		"\n"
		"(Alternate spelling) Returns the 'organization' stored in this\n"
		"ModelCreator object.\n"
		"\n"
		"Note: This function is an alias of getOrganization().\n"
		"\n"
		"Returns organization from the ModelCreator.\n"
		"\n"
		"See also getOrganization().\n"
		"\n"
		""},
	 { "ModelCreator_getName", _wrap_ModelCreator_getName, METH_O, "\n"
		"ModelCreator_getName(ModelCreator self) -> string\n"
		"\n"
		"Returns the 'fn' stored in this ModelCreator object when using vCard4.\n"
		"\n"
		"Returns the 'fn' portion of the ModelCreator object.\n"
		"\n"
		""},
	 { "ModelCreator_isSetFamilyName", _wrap_ModelCreator_isSetFamilyName, METH_O, "\n"
		"ModelCreator_isSetFamilyName(ModelCreator self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this\n"
		"ModelCreator's 'family name' part is set.\n"
		"\n"
		"Returns 'True' if the familyName of this ModelCreator is set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ModelCreator_isSetGivenName", _wrap_ModelCreator_isSetGivenName, METH_O, "\n"
		"ModelCreator_isSetGivenName(ModelCreator self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this\n"
		"ModelCreator's 'given name' part is set.\n"
		"\n"
		"Returns 'True' if the givenName of this ModelCreator is set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ModelCreator_isSetEmail", _wrap_ModelCreator_isSetEmail, METH_O, "\n"
		"ModelCreator_isSetEmail(ModelCreator self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this\n"
		"ModelCreator's 'email' part is set.\n"
		"\n"
		"Returns 'True' if the email of this ModelCreator is set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ModelCreator_isSetOrganization", _wrap_ModelCreator_isSetOrganization, METH_O, "\n"
		"ModelCreator_isSetOrganization(ModelCreator self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this\n"
		"ModelCreator's 'organization' part is set.\n"
		"\n"
		"Returns 'True' if the organization of this ModelCreator is set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "ModelCreator_isSetOrganisation", _wrap_ModelCreator_isSetOrganisation, METH_O, "\n"
		"ModelCreator_isSetOrganisation(ModelCreator self) -> bool\n"
		"\n"
		"(Alternate spelling) Predicate returning 'True' or 'False' depending\n"
		"on whether this ModelCreator's 'organization' part is set.\n"
		"\n"
		"Note: This function is an alias of isSetOrganization().\n"
		"\n"
		"Returns 'True' if the organization of this ModelCreator is set,\n"
		"'False' otherwise.\n"
		"\n"
		"See also isSetOrganization().\n"
		"\n"
		""},
	 { "ModelCreator_isSetName", _wrap_ModelCreator_isSetName, METH_O, "\n"
		"ModelCreator_isSetName(ModelCreator self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this\n"
		"ModelCreator's 'fn' part is set (when using vCard4).\n"
		"\n"
		"Returns 'True' if the fn of this ModelCreator is set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ModelCreator_setFamilyName", _wrap_ModelCreator_setFamilyName, METH_VARARGS, "\n"
		"ModelCreator_setFamilyName(ModelCreator self, string familyName) -> int\n"
		"\n"
		"Sets the 'family name' portion of this ModelCreator object.\n"
		"\n"
		"Parameter 'familyName' is a string representing the familyName of the\n"
		"ModelCreator.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "ModelCreator_setGivenName", _wrap_ModelCreator_setGivenName, METH_VARARGS, "\n"
		"ModelCreator_setGivenName(ModelCreator self, string givenName) -> int\n"
		"\n"
		"Sets the 'given name' portion of this ModelCreator object.\n"
		"\n"
		"Parameter 'givenName' is a string representing the givenName of the\n"
		"ModelCreator.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "ModelCreator_setEmail", _wrap_ModelCreator_setEmail, METH_VARARGS, "\n"
		"ModelCreator_setEmail(ModelCreator self, string email) -> int\n"
		"\n"
		"Sets the 'email' portion of this ModelCreator object.\n"
		"\n"
		"Parameter 'email' is a string representing the email of the\n"
		"ModelCreator.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "ModelCreator_setOrganization", _wrap_ModelCreator_setOrganization, METH_VARARGS, "\n"
		"ModelCreator_setOrganization(ModelCreator self, string organization) -> int\n"
		"\n"
		"Sets the 'organization' portion of this ModelCreator object.\n"
		"\n"
		"Parameter 'organization' is a string representing the organization of\n"
		"the  ModelCreator.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "ModelCreator_setOrganisation", _wrap_ModelCreator_setOrganisation, METH_VARARGS, "\n"
		"ModelCreator_setOrganisation(ModelCreator self, string organization) -> int\n"
		"\n"
		"(Alternate spelling) Sets the 'organization' portion of this\n"
		"ModelCreator object.\n"
		"\n"
		"Parameter 'organization' is a string representing the organization of\n"
		"the ModelCreator.\n"
		"\n"
		"Note: This function is an alias of setOrganization(string\n"
		"organization).\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"See also setOrganization().\n"
		"\n"
		""},
	 { "ModelCreator_setName", _wrap_ModelCreator_setName, METH_VARARGS, "\n"
		"ModelCreator_setName(ModelCreator self, string name) -> int\n"
		"\n"
		"Sets the 'fn' portion of this ModelCreator object (when using vCard4).\n"
		"\n"
		"Parameter 'name' is a string representing the fn of the ModelCreator.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "ModelCreator_unsetFamilyName", _wrap_ModelCreator_unsetFamilyName, METH_O, "\n"
		"ModelCreator_unsetFamilyName(ModelCreator self) -> int\n"
		"\n"
		"Unsets the 'family name' portion of this ModelCreator object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "ModelCreator_unsetGivenName", _wrap_ModelCreator_unsetGivenName, METH_O, "\n"
		"ModelCreator_unsetGivenName(ModelCreator self) -> int\n"
		"\n"
		"Unsets the 'given name' portion of this ModelCreator object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "ModelCreator_unsetEmail", _wrap_ModelCreator_unsetEmail, METH_O, "\n"
		"ModelCreator_unsetEmail(ModelCreator self) -> int\n"
		"\n"
		"Unsets the 'email' portion of this ModelCreator object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "ModelCreator_unsetOrganization", _wrap_ModelCreator_unsetOrganization, METH_O, "\n"
		"ModelCreator_unsetOrganization(ModelCreator self) -> int\n"
		"\n"
		"Unsets the 'organization' portion of this ModelCreator object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "ModelCreator_unsetOrganisation", _wrap_ModelCreator_unsetOrganisation, METH_O, "\n"
		"ModelCreator_unsetOrganisation(ModelCreator self) -> int\n"
		"\n"
		"(Alternate spelling) Unsets the 'organization' portion of this\n"
		"ModelCreator object.\n"
		"\n"
		"Note: This function is an alias of unsetOrganization().\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also unsetOrganization().\n"
		"\n"
		""},
	 { "ModelCreator_unsetName", _wrap_ModelCreator_unsetName, METH_O, "\n"
		"ModelCreator_unsetName(ModelCreator self) -> int\n"
		"\n"
		"Unsets the 'fn' portion of this ModelCreator object (when using\n"
		"vCard4).\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "ModelCreator_hasRequiredAttributes", _wrap_ModelCreator_hasRequiredAttributes, METH_O, "\n"
		"ModelCreator_hasRequiredAttributes(ModelCreator self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this\n"
		"ModelCreator object have been set.\n"
		"\n"
		"The only required elements for a ModelCreator object are the 'family\n"
		"name' and 'given name'.\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "ModelCreator_hasBeenModified", _wrap_ModelCreator_hasBeenModified, METH_O, "\n"
		"ModelCreator_hasBeenModified(ModelCreator self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ModelCreator_resetModifiedFlags", _wrap_ModelCreator_resetModifiedFlags, METH_O, "\n"
		"ModelCreator_resetModifiedFlags(ModelCreator self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ModelCreator_usingFNVcard4", _wrap_ModelCreator_usingFNVcard4, METH_O, "\n"
		"ModelCreator_usingFNVcard4(ModelCreator self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ModelCreator_usingSingleName", _wrap_ModelCreator_usingSingleName, METH_O, "\n"
		"ModelCreator_usingSingleName(ModelCreator self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ModelCreator_setUseSingleName", _wrap_ModelCreator_setUseSingleName, METH_VARARGS, "\n"
		"ModelCreator_setUseSingleName(ModelCreator self, bool flag)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ModelCreator_swigregister", ModelCreator_swigregister, METH_O, NULL},
	 { "ModelCreator_swiginit", ModelCreator_swiginit, METH_VARARGS, NULL},
	 { "delete_ModelHistory", _wrap_delete_ModelHistory, METH_O, "delete_ModelHistory(ModelHistory self)"},
	 { "new_ModelHistory", _wrap_new_ModelHistory, METH_VARARGS, "\n"
		"ModelHistory()\n"
		"new_ModelHistory(ModelHistory orig) -> ModelHistory\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ModelHistory(ModelHistory orig)\n"
		"\n"
		"Copy constructor; creates a copy of this ModelHistory object.\n"
		"\n"
		"Parameter 'orig' is the object to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ModelHistory()\n"
		"\n"
		"Creates a new ModelHistory object.\n"
		"\n"
		""},
	 { "ModelHistory_clone", _wrap_ModelHistory_clone, METH_O, "\n"
		"ModelHistory_clone(ModelHistory self) -> ModelHistory\n"
		"\n"
		"Creates and returns a deep copy of this ModelHistory object.\n"
		"\n"
		"Returns the (deep) copy of this ModelHistory object.\n"
		"\n"
		""},
	 { "ModelHistory_getCreatedDate", _wrap_ModelHistory_getCreatedDate, METH_O, "\n"
		"ModelHistory_getCreatedDate(ModelHistory self) -> Date\n"
		"\n"
		"Returns the 'creation date' portion of this ModelHistory object.\n"
		"\n"
		"Returns a Date object representing the creation date stored in this\n"
		"ModelHistory object.\n"
		"\n"
		""},
	 { "ModelHistory_isSetCreatedDate", _wrap_ModelHistory_isSetCreatedDate, METH_O, "\n"
		"ModelHistory_isSetCreatedDate(ModelHistory self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this\n"
		"ModelHistory's 'creation date' is set.\n"
		"\n"
		"Returns 'True' if the creation date value of this ModelHistory is set,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "ModelHistory_isSetModifiedDate", _wrap_ModelHistory_isSetModifiedDate, METH_O, "\n"
		"ModelHistory_isSetModifiedDate(ModelHistory self) -> bool\n"
		"\n"
		"Predicate returning 'True' or 'False' depending on whether this\n"
		"ModelHistory's 'modified date' is set.\n"
		"\n"
		"Returns 'True' if the modification date value of this ModelHistory\n"
		"object is set, 'False' otherwise.\n"
		"\n"
		""},
	 { "ModelHistory_setCreatedDate", _wrap_ModelHistory_setCreatedDate, METH_VARARGS, "\n"
		"ModelHistory_setCreatedDate(ModelHistory self, Date date) -> int\n"
		"\n"
		"Sets the creation date of this ModelHistory object.\n"
		"\n"
		"Parameter 'date' is a Date object representing the date to which the\n"
		"'created date' portion of this ModelHistory should be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "ModelHistory_setModifiedDate", _wrap_ModelHistory_setModifiedDate, METH_VARARGS, "\n"
		"ModelHistory_setModifiedDate(ModelHistory self, Date date) -> int\n"
		"\n"
		"Sets the modification date of this ModelHistory object.\n"
		"\n"
		"Parameter 'date' is a Date object representing the date to which the\n"
		"'modified date' portion of this ModelHistory should be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "ModelHistory_addModifiedDate", _wrap_ModelHistory_addModifiedDate, METH_VARARGS, "\n"
		"ModelHistory_addModifiedDate(ModelHistory self, Date date) -> int\n"
		"\n"
		"Adds a copy of a Date object to the list of 'modified date' values\n"
		"stored in this ModelHistory object.\n"
		"\n"
		"In the MIRIAM format for annotations, there can be multiple\n"
		"modification dates.  The libSBML ModelHistory class supports this by\n"
		"storing a list of 'modified date' values.\n"
		"\n"
		"Parameter 'date' is a Date object representing the 'modified date'\n"
		"that should be added to this ModelHistory object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "ModelHistory_getListModifiedDates", _wrap_ModelHistory_getListModifiedDates, METH_O, "\n"
		"ModelHistory_getListModifiedDates(ModelHistory self) -> List *\n"
		"\n"
		"Returns the list of 'modified date' values (as Date objects) stored in\n"
		"this ModelHistory object.\n"
		"\n"
		"In the MIRIAM format for annotations, there can be multiple\n"
		"modification dates.  The libSBML ModelHistory class supports this by\n"
		"storing a list of 'modified date' values.\n"
		"\n"
		"Returns the list of modification dates for this ModelHistory object.\n"
		"\n"
		""},
	 { "ModelHistory_getModifiedDate", _wrap_ModelHistory_getModifiedDate, METH_VARARGS, "\n"
		"ModelHistory_getModifiedDate(ModelHistory self) -> Date\n"
		"ModelHistory_getModifiedDate(ModelHistory self, unsigned int n) -> Date\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getModifiedDate()\n"
		"\n"
		"Returns the 'modified date' portion of this ModelHistory object.\n"
		"\n"
		"Note that in the MIRIAM format for annotations, there can be multiple\n"
		"modification dates.  The libSBML ModelHistory class supports this by\n"
		"storing a list of 'modified date' values.  If this ModelHistory object\n"
		"contains more than one 'modified date' value in the list, this method\n"
		"will return the first one in the list.\n"
		"\n"
		"Returns a Date object representing the date of modification stored in\n"
		"this ModelHistory object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getModifiedDate(long n)\n"
		"\n"
		"Get the nth Date object in the list of 'modified date' values stored\n"
		"in this ModelHistory object.\n"
		"\n"
		"In the MIRIAM format for annotations, there can be multiple\n"
		"modification dates.  The libSBML ModelHistory class supports this by\n"
		"storing a list of 'modified date' values.\n"
		"\n"
		"Returns the nth Date in the list of ModifiedDates of this ModelHistory\n"
		"or 'None' if no such object exists.\n"
		"\n"
		""},
	 { "ModelHistory_getNumModifiedDates", _wrap_ModelHistory_getNumModifiedDates, METH_O, "\n"
		"ModelHistory_getNumModifiedDates(ModelHistory self) -> unsigned int\n"
		"\n"
		"Get the number of Date objects in this ModelHistory object's list of\n"
		"'modified dates'.\n"
		"\n"
		"In the MIRIAM format for annotations, there can be multiple\n"
		"modification dates.  The libSBML ModelHistory class supports this by\n"
		"storing a list of 'modified date' values.\n"
		"\n"
		"Returns the number of ModifiedDates in this ModelHistory.\n"
		"\n"
		""},
	 { "ModelHistory_addCreator", _wrap_ModelHistory_addCreator, METH_VARARGS, "\n"
		"ModelHistory_addCreator(ModelHistory self, ModelCreator mc) -> int\n"
		"\n"
		"Adds a copy of a ModelCreator object to the list of 'model creator'\n"
		"values stored in this ModelHistory object.\n"
		"\n"
		"In the MIRIAM format for annotations, there can be multiple model\n"
		"creators.  The libSBML ModelHistory class supports this by storing a\n"
		"list of 'model creator' values.\n"
		"\n"
		"Parameter 'mc' is the ModelCreator to add.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "ModelHistory_getListCreators", _wrap_ModelHistory_getListCreators, METH_O, "\n"
		"ModelHistory_getListCreators(ModelHistory self) -> List *\n"
		"\n"
		"Returns the list of ModelCreator objects stored in this ModelHistory\n"
		"object.\n"
		"\n"
		"In the MIRIAM format for annotations, there can be multiple model\n"
		"creators.  The libSBML ModelHistory class supports this by storing a\n"
		"list of 'model creator' values.\n"
		"\n"
		"Returns the list of ModelCreator objects.\n"
		"\n"
		""},
	 { "ModelHistory_getCreator", _wrap_ModelHistory_getCreator, METH_VARARGS, "\n"
		"ModelHistory_getCreator(ModelHistory self, unsigned int n) -> ModelCreator\n"
		"\n"
		"Get the nth ModelCreator object stored in this ModelHistory object.\n"
		"\n"
		"In the MIRIAM format for annotations, there can be multiple model\n"
		"creators.  The libSBML ModelHistory class supports this by storing a\n"
		"list of 'model creator' values.\n"
		"\n"
		"Returns the nth ModelCreator object or 'None' if no such object\n"
		"exists.\n"
		"\n"
		""},
	 { "ModelHistory_getNumCreators", _wrap_ModelHistory_getNumCreators, METH_O, "\n"
		"ModelHistory_getNumCreators(ModelHistory self) -> unsigned int\n"
		"\n"
		"Get the number of ModelCreator objects stored in this ModelHistory\n"
		"object.\n"
		"\n"
		"In the MIRIAM format for annotations, there can be multiple model\n"
		"creators.  The libSBML ModelHistory class supports this by storing a\n"
		"list of 'model creator' values.\n"
		"\n"
		"Returns the number of ModelCreators objects.\n"
		"\n"
		""},
	 { "ModelHistory_hasRequiredAttributes", _wrap_ModelHistory_hasRequiredAttributes, METH_O, "\n"
		"ModelHistory_hasRequiredAttributes(ModelHistory self) -> bool\n"
		"\n"
		"Predicate returning 'True' if all the required elements for this\n"
		"ModelHistory object have been set.\n"
		"\n"
		"The required elements for a ModelHistory object are 'created name',\n"
		"'modified date', and at least one 'model creator'.\n"
		"\n"
		"Returns a boolean value indicating whether all the required elements\n"
		"for this object have been defined.\n"
		"\n"
		""},
	 { "ModelHistory_hasBeenModified", _wrap_ModelHistory_hasBeenModified, METH_O, "\n"
		"ModelHistory_hasBeenModified(ModelHistory self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ModelHistory_resetModifiedFlags", _wrap_ModelHistory_resetModifiedFlags, METH_O, "\n"
		"ModelHistory_resetModifiedFlags(ModelHistory self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ModelHistory_swigregister", ModelHistory_swigregister, METH_O, NULL},
	 { "ModelHistory_swiginit", ModelHistory_swiginit, METH_VARARGS, NULL},
	 { "RDFAnnotationParser_createAnnotation", _wrap_RDFAnnotationParser_createAnnotation, METH_NOARGS, "\n"
		"RDFAnnotationParser_createAnnotation() -> XMLNode\n"
		"\n"
		"Creates a blank annotation and returns its root XMLNode object.\n"
		"\n"
		"This creates a completely empty SBML <annotation> element.  It is not\n"
		"attached to any SBML element.  An example of how this might be used is\n"
		"illustrated in the following code fragment.  In this example, suppose\n"
		"that 'content' is an XMLNode object previously created, containing\n"
		"MIRIAM-style annotations, and that 'sbmlObject' is an SBML object\n"
		"derived from SBase (e.g., a Model, or a Species, or a Compartment,\n"
		"etc.).  Then:\n"
		"\n"
		"  RDF     = RDFAnnotationParser.createRDFAnnotation() # Create XML structure.\n"
		"  success = RDF.addChild(...content...)               # Put some content into it.\n"
		"  ...                                                 # Check return code value.\n"
		"\n"
		"  annot   = RDFAnnotationParser.createAnnotation()    # Create <annotation>.\n"
		"  success = annot.addChild(RDF)                       # Put the annotation into it.\n"
		"  ...                                                 # Check return code value.\n"
		"\n"
		"  success = sbmlObject.setAnnotation(annot)           # Set object's annotation.\n"
		"  ...                                                 # Check return code value.\n"
		"\n"
		"The SBML specification contains more information about the format of\n"
		"annotations.  We urge readers to consult Section 6 of the SBML Level 2\n"
		"(Versions 2-4) and SBML Level 3 specification documents.\n"
		"\n"
		"Returns a pointer to an XMLNode for the annotation.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also RDFAnnotationParser.createRDFAnnotation() .\n"
		"\n"
		""},
	 { "RDFAnnotationParser_createRDFAnnotation", _wrap_RDFAnnotationParser_createRDFAnnotation, METH_VARARGS, "\n"
		"RDFAnnotationParser_createRDFAnnotation(unsigned int level=3, unsigned int version=1) -> XMLNode\n"
		"\n"
		"Creates a blank RDF element suitable for use in SBML annotations.\n"
		"\n"
		"The annotation created by this method has namespace declarations for\n"
		"all the relevant XML namespaces used in RDF annotations and also has\n"
		"an empty RDF element.  The result is the following XML:\n"
		"\n"
		"  <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'\n"
		"           xmlns:dc='http://purl.org/dc/elements/1.1/'\n"
		"           xmlns:dcterms='http://purl.org/dc/terms/'\n"
		"           xmlns:vCard='http://www.w3.org/2001/vcard-rdf/3.0#'\n"
		"           xmlns:bqbiol='http://biomodels.net/biology-qualifiers/'\n"
		"           xmlns:bqmodel='http://biomodels.net/model-qualifiers/' >\n"
		"\n"
		"  </rdf:RDF>\n"
		"\n"
		"Note that this does not create the containing SBML <annotation>\n"
		"element; the method RDFAnnotationParser.createAnnotation() is\n"
		"available for creating the container.\n"
		"\n"
		"Returns a pointer to an XMLNode.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		"See also RDFAnnotationParser.createAnnotation() .\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "RDFAnnotationParser_createCVTerms", _wrap_RDFAnnotationParser_createCVTerms, METH_O, "\n"
		"RDFAnnotationParser_createCVTerms(SBase obj) -> XMLNode\n"
		"\n"
		"Takes a list of CVTerm objects and creates a the RDF 'Description'\n"
		"element.\n"
		"\n"
		"This essentially takes the given SBML object, reads out the CVTerm\n"
		"objects attached to it, creates an RDF 'Description' element to hold\n"
		"the terms, and adds each term with appropriate qualifiers.\n"
		"\n"
		"Parameter 'obj' is the SBML object to start from.\n"
		"\n"
		"Returns the XMLNode tree corresponding to the Description element of\n"
		"an RDF annotation.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "RDFAnnotationParser_parseCVTerms", _wrap_RDFAnnotationParser_parseCVTerms, METH_O, "\n"
		"RDFAnnotationParser_parseCVTerms(SBase obj) -> XMLNode\n"
		"\n"
		"Takes a list of CVTerm objects and creates a complete SBML annotation\n"
		"around it.\n"
		"\n"
		"This essentially takes the given SBML object, reads out the CVTerm\n"
		"objects attached to it, calls\n"
		"RDFAnnotationParser.createRDFAnnotation() to create an RDF annotation\n"
		"to hold the terms, and finally calls\n"
		"RDFAnnotationParser.createAnnotation() to wrap the result as an SBML\n"
		"<annotation> element.\n"
		"\n"
		"Parameter 'obj' is the SBML object to start from.\n"
		"\n"
		"Returns the XMLNode tree corresponding to the annotation.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "RDFAnnotationParser_parseModelHistory", _wrap_RDFAnnotationParser_parseModelHistory, METH_O, "\n"
		"RDFAnnotationParser_parseModelHistory(SBase obj) -> XMLNode\n"
		"\n"
		"Reads the model history and cvTerms stored in 'obj' and creates the\n"
		"XML structure for an SBML annotation representing that metadata if\n"
		"there is a model history stored in 'obj'.\n"
		"\n"
		"Parameter 'obj' is any SBase object.\n"
		"\n"
		"Returns the XMLNode corresponding to an annotation containing  MIRIAM-\n"
		"compliant model history and CV term information in RDF format.\n"
		"\n"
		"Note: If the object does not have a history element stored then 'None'\n"
		"is returned even if CVTerms are present.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "RDFAnnotationParser_parseOnlyModelHistory", _wrap_RDFAnnotationParser_parseOnlyModelHistory, METH_O, "\n"
		"RDFAnnotationParser_parseOnlyModelHistory(SBase obj) -> XMLNode\n"
		"\n"
		"Reads the model history stored in 'obj' and creates the XML structure\n"
		"for an SBML annotation representing that history.\n"
		"\n"
		"Parameter 'obj' is any SBase object.\n"
		"\n"
		"Returns the XMLNode corresponding to an annotation containing  MIRIAM-\n"
		"compliant model history information in RDF format.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "RDFAnnotationParser_deleteRDFAnnotation", _wrap_RDFAnnotationParser_deleteRDFAnnotation, METH_O, "\n"
		"RDFAnnotationParser_deleteRDFAnnotation(XMLNode annotation) -> XMLNode\n"
		"\n"
		"Deletes any SBML MIRIAM RDF annotation found in the given XMLNode\n"
		"tree and returns any remaining annotation content.\n"
		"\n"
		"The name of the XMLNode given as parameter 'annotation' must be\n"
		"'annotation', or else this method returns 'None.'  The method will\n"
		"walk down the XML structure looking for elements that are in the RDF\n"
		"XML namespace, and remove them if they conform to the syntax of a\n"
		"History or CVTerm element.\n"
		"\n"
		"Parameter 'annotation' is the XMLNode tree within which the RDF\n"
		"annotation is to be found and deleted.\n"
		"\n"
		"Returns the XMLNode structure that is left after RDF annotations are\n"
		"deleted.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "RDFAnnotationParser_deleteRDFHistoryAnnotation", _wrap_RDFAnnotationParser_deleteRDFHistoryAnnotation, METH_O, "\n"
		"RDFAnnotationParser_deleteRDFHistoryAnnotation(XMLNode annotation) -> XMLNode\n"
		"\n"
		"Deletes any SBML MIRIAM RDF 'History' annotation found in the given\n"
		"XMLNode tree and returns any remaining annotation content.\n"
		"\n"
		"The name of the XMLNode given as parameter 'annotation' must be\n"
		"'annotation', or else this method returns 'None.'  The method will\n"
		"walk down the XML structure looking for elements that are in the RDF\n"
		"XML namespace, and remove any that conform to the syntax of a History\n"
		"element.\n"
		"\n"
		"Parameter 'annotation' is the XMLNode tree within which the RDF\n"
		"annotation is to be found and deleted.\n"
		"\n"
		"Returns the XMLNode structure that is left after RDF annotations are\n"
		"deleted.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "RDFAnnotationParser_deleteRDFCVTermAnnotation", _wrap_RDFAnnotationParser_deleteRDFCVTermAnnotation, METH_O, "\n"
		"RDFAnnotationParser_deleteRDFCVTermAnnotation(XMLNode annotation) -> XMLNode\n"
		"\n"
		"Deletes any SBML MIRIAM RDF 'CVTerm' annotation found in the given\n"
		"XMLNode tree and returns any remaining annotation content.\n"
		"\n"
		"The name of the XMLNode given as parameter 'annotation' must be\n"
		"'annotation', or else this method returns 'None.'  The method will\n"
		"walk down the XML structure looking for elements that are in the RDF\n"
		"XML namespace, and remove any that conform to the syntax of a CVTerm\n"
		"element.\n"
		"\n"
		"Parameter 'annotation' is the XMLNode tree within which the RDF\n"
		"annotation is to be found and deleted.\n"
		"\n"
		"Returns the XMLNode structure that is left after RDF annotations are\n"
		"deleted.\n"
		"\n"
		"Note: Because this is a static method on a class, the Python language\n"
		"interface for libSBML will contain two variants.  One will be the\n"
		"expected, normal static method on the class (i.e., a regular\n"
		"methodName), and the other will be a standalone top-level function\n"
		"with the name ClassName_methodName(). This is merely an artifact of\n"
		"how the language interfaces are created in libSBML.  The methods are\n"
		"functionally identical.\n"
		"\n"
		""},
	 { "RDFAnnotationParser_parseRDFAnnotation", _wrap_RDFAnnotationParser_parseRDFAnnotation, METH_VARARGS, "\n"
		"RDFAnnotationParser_parseRDFAnnotation(XMLNode annotation, char const * metaId=None, XMLInputStream stream=None) -> ModelHistory\n"
		"RDFAnnotationParser_parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms)\n"
		"RDFAnnotationParser_parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms, char const * metaId=None, XMLInputStream stream=None)\n"
		"\n"
		"Parses an annotation (given as an XMLNode tree) into a list of\n"
		"CVTerm objects.\n"
		"\n"
		"This is used to take an annotation that has been read into an SBML\n"
		"model, identify the RDF elements within it, and create a list of\n"
		"corresponding CVTerm (controlled vocabulary term) objects.\n"
		"\n"
		"@param annotation XMLNode containing the annotation.\n"
		"@param CVTerms list of CVTerm objects to be created.\n"
		"@param metaId optional metaId, if set only the RDF annotation for this metaId will be returned.\n"
		"@param stream optional XMLInputStream that facilitates error logging.\n"
		"\n"
		"@copydetails doc_note_static_methods\n"
		"\n"
		"@htmlinclude warn-default-args-in-docs.html\n"
		"\n"
		""},
	 { "new_RDFAnnotationParser", _wrap_new_RDFAnnotationParser, METH_NOARGS, "\n"
		"new_RDFAnnotationParser() -> RDFAnnotationParser\n"
		"\n"
		"@internal\n"
		"\n"
		""},
	 { "delete_RDFAnnotationParser", _wrap_delete_RDFAnnotationParser, METH_O, "delete_RDFAnnotationParser(RDFAnnotationParser self)"},
	 { "RDFAnnotationParser_swigregister", RDFAnnotationParser_swigregister, METH_O, NULL},
	 { "RDFAnnotationParser_swiginit", RDFAnnotationParser_swiginit, METH_VARARGS, NULL},
	 { "delete_ISBMLExtensionNamespaces", _wrap_delete_ISBMLExtensionNamespaces, METH_O, "delete_ISBMLExtensionNamespaces(ISBMLExtensionNamespaces self)"},
	 { "ISBMLExtensionNamespaces_getURI", _wrap_ISBMLExtensionNamespaces_getURI, METH_O, "\n"
		"ISBMLExtensionNamespaces_getURI(ISBMLExtensionNamespaces self) -> string\n"
		"\n"
		"Returns a string representing the SBML XML namespace of this object.\n"
		"\n"
		"Returns a string representing the SBML namespace that reflects the\n"
		"SBML Level and Version of this object.\n"
		"\n"
		""},
	 { "ISBMLExtensionNamespaces_getPackageVersion", _wrap_ISBMLExtensionNamespaces_getPackageVersion, METH_O, "ISBMLExtensionNamespaces_getPackageVersion(ISBMLExtensionNamespaces self) -> unsigned int"},
	 { "ISBMLExtensionNamespaces_getPackageName", _wrap_ISBMLExtensionNamespaces_getPackageName, METH_O, "\n"
		"ISBMLExtensionNamespaces_getPackageName(ISBMLExtensionNamespaces self) -> string\n"
		"\n"
		"Returns the name of the main package for this namespace.\n"
		"\n"
		"Returns the name of the main package for this namespace. 'core' will\n"
		"be returned if this namespace is defined in the SBML  core.\n"
		"\n"
		""},
	 { "ISBMLExtensionNamespaces_setPackageVersion", _wrap_ISBMLExtensionNamespaces_setPackageVersion, METH_VARARGS, "ISBMLExtensionNamespaces_setPackageVersion(ISBMLExtensionNamespaces self, unsigned int pkgVersion)"},
	 { "ISBMLExtensionNamespaces_swigregister", ISBMLExtensionNamespaces_swigregister, METH_O, NULL},
	 { "delete_SBaseExtensionPoint", _wrap_delete_SBaseExtensionPoint, METH_O, "delete_SBaseExtensionPoint(SBaseExtensionPoint self)"},
	 { "new_SBaseExtensionPoint", _wrap_new_SBaseExtensionPoint, METH_VARARGS, "\n"
		"SBaseExtensionPoint(string pkgName, int typeCode)\n"
		"SBaseExtensionPoint(string pkgName, int typeCode, string elementName, bool elementOnly=False)\n"
		"new_SBaseExtensionPoint(SBaseExtensionPoint rhs) -> SBaseExtensionPoint\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBaseExtensionPoint(string pkgName, int typeCode, string\n"
		"elementName, bool elementOnly = false)\n"
		"\n"
		"Constructor for SBaseExtensionPoint.\n"
		"\n"
		"The use of SBaseExtensionPoint is relatively straightforward.  The\n"
		"class needs to be used for each extended SBML object implemented using\n"
		"SBMLDocumentPlugin or SBasePlugin.  Doing so requires knowing just two\n"
		"things:\n"
		"\n"
		"* The short-form name of the parent package being extended. The\n"
		"parent package is often simply core SBML, identified in libSBML by the\n"
		"nickname 'core', but a SBML Level 3 package could conceivably extend\n"
		"another Level 3 package and the mechanism supports this.\n"
		"\n"
		"* The libSBML type code assigned to the object being extended. For\n"
		"example, if an extension of Model is implemented, the relevant type\n"
		"code is SBML_MODEL, found in #SBMLTypeCode_t.\n"
		"\n"
		"Parameter 'pkgName' is the short-form name of the parent package where\n"
		"that this package extension is extending.\n"
		"\n"
		"Parameter 'typeCode' is the type code of the object being extended.\n"
		"\n"
		"Parameter 'elementName' is element name for the target element, in\n"
		"case  multiple elements match the same type code (as will be the case\n"
		"for ListOf classes).\n"
		"\n"
		"Parameter 'elementOnly' is flag to be used during the registration  of\n"
		"the package, when set then the plugin is only applied to  elements\n"
		"whose elementName match.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBaseExtensionPoint( SBaseExtensionPoint rhs)\n"
		"\n"
		"Copy constructor.\n"
		"\n"
		"This creates a copy of an SBaseExtensionPoint instance.\n"
		"\n"
		"Parameter 'rhs' is the object to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBaseExtensionPoint(string pkgName, int typeCode)\n"
		"\n"
		"Constructor for SBaseExtensionPoint.\n"
		"\n"
		"The use of SBaseExtensionPoint is relatively straightforward.  The\n"
		"class needs to be used for each extended SBML object implemented using\n"
		"SBMLDocumentPlugin or SBasePlugin.  Doing so requires knowing just two\n"
		"things:\n"
		"\n"
		"* The short-form name of the parent package being extended. The\n"
		"parent package is often simply core SBML, identified in libSBML by the\n"
		"nickname 'core', but a SBML Level 3 package could conceivably extend\n"
		"another Level 3 package and the mechanism supports this.\n"
		"\n"
		"* The libSBML type code assigned to the object being extended. For\n"
		"example, if an extension of Model is implemented, the relevant type\n"
		"code is SBML_MODEL, found in #SBMLTypeCode_t.\n"
		"\n"
		"Parameter 'pkgName' is the short-form name of the parent package where\n"
		"that this package extension is extending.\n"
		"\n"
		"Parameter 'typeCode' is the type code of the object being extended.\n"
		"\n"
		""},
	 { "SBaseExtensionPoint_clone", _wrap_SBaseExtensionPoint_clone, METH_O, "\n"
		"SBaseExtensionPoint_clone(SBaseExtensionPoint self) -> SBaseExtensionPoint\n"
		"\n"
		"Creates and returns a deep copy of this SBaseExtensionPoint object.\n"
		"\n"
		"Returns the (deep) copy of this SBaseExtensionPoint object.\n"
		"\n"
		""},
	 { "SBaseExtensionPoint_getPackageName", _wrap_SBaseExtensionPoint_getPackageName, METH_O, "\n"
		"SBaseExtensionPoint_getPackageName(SBaseExtensionPoint self) -> string\n"
		"\n"
		"Returns the package name of this extension point.\n"
		"\n"
		""},
	 { "SBaseExtensionPoint_getTypeCode", _wrap_SBaseExtensionPoint_getTypeCode, METH_O, "\n"
		"SBaseExtensionPoint_getTypeCode(SBaseExtensionPoint self) -> int\n"
		"\n"
		"Returns the libSBML type code of this extension point.\n"
		"\n"
		""},
	 { "SBaseExtensionPoint_getElementName", _wrap_SBaseExtensionPoint_getElementName, METH_O, "\n"
		"SBaseExtensionPoint_getElementName(SBaseExtensionPoint self) -> string\n"
		"\n"
		"the target element name\n"
		"\n"
		""},
	 { "SBaseExtensionPoint_isElementOnly", _wrap_SBaseExtensionPoint_isElementOnly, METH_O, "\n"
		"SBaseExtensionPoint_isElementOnly(SBaseExtensionPoint self) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "SBaseExtensionPoint_swigregister", SBaseExtensionPoint_swigregister, METH_O, NULL},
	 { "SBaseExtensionPoint_swiginit", SBaseExtensionPoint_swiginit, METH_VARARGS, NULL},
	 { "delete_SBasePlugin", _wrap_delete_SBasePlugin, METH_O, "delete_SBasePlugin(SBasePlugin self)"},
	 { "SBasePlugin_getElementNamespace", _wrap_SBasePlugin_getElementNamespace, METH_O, "\n"
		"SBasePlugin_getElementNamespace(SBasePlugin self) -> string\n"
		"\n"
		"Returns the namespace URI of the package to which this plugin object\n"
		"belongs.\n"
		"\n"
		"Returns the XML namespace URI of the SBML Level 3 package implemented\n"
		"by this libSBML package extension.\n"
		"\n"
		""},
	 { "SBasePlugin_getPrefix", _wrap_SBasePlugin_getPrefix, METH_O, "\n"
		"SBasePlugin_getPrefix(SBasePlugin self) -> string\n"
		"\n"
		"Returns the XML namespace prefix of the package to which this plugin\n"
		"object belongs.\n"
		"\n"
		"Returns the XML namespace prefix of the SBML Level 3 package\n"
		"implemented by this libSBML package extension.\n"
		"\n"
		""},
	 { "SBasePlugin_getPackageName", _wrap_SBasePlugin_getPackageName, METH_O, "\n"
		"SBasePlugin_getPackageName(SBasePlugin self) -> string\n"
		"\n"
		"Returns the short-form name of the package to which this plugin object\n"
		"belongs.\n"
		"\n"
		"Returns the short-form package name (or nickname) of the SBML package\n"
		"implemented by this package extension.\n"
		"\n"
		""},
	 { "SBasePlugin_clone", _wrap_SBasePlugin_clone, METH_O, "\n"
		"SBasePlugin_clone(SBasePlugin self) -> SBasePlugin\n"
		"\n"
		"Creates and returns a deep copy of this SBasePlugin object.\n"
		"\n"
		"Returns the (deep) copy of this SBasePlugin object.\n"
		"\n"
		""},
	 { "SBasePlugin_getElementBySId", _wrap_SBasePlugin_getElementBySId, METH_VARARGS, "\n"
		"SBasePlugin_getElementBySId(SBasePlugin self, string id) -> SBase\n"
		"\n"
		"Return the first child object found with a given identifier.\n"
		"\n"
		"This method searches all the subobjects under this one, compares their\n"
		"identifiers to 'id', and returns the first one that machines.\n"
		"\n"
		"Normally, SId type identifier values are unique across a model in\n"
		"SBML.  However, in some circumstances they may not be, such as if a\n"
		"model is invalid because of multiple objects having the same\n"
		"identifier.\n"
		"\n"
		"Parameter 'id' is string representing the identifier of the object to\n"
		"find.\n"
		"\n"
		"Returns pointer to the first object with the given 'id'.\n"
		"\n"
		""},
	 { "SBasePlugin_getElementByMetaId", _wrap_SBasePlugin_getElementByMetaId, METH_VARARGS, "\n"
		"SBasePlugin_getElementByMetaId(SBasePlugin self, string metaid) -> SBase\n"
		"\n"
		"Return the first child object found with a given meta identifier.\n"
		"\n"
		"This method searches all the subobjects under this one, compares their\n"
		"meta identifiers to 'metaid', and returns the first one that machines.\n"
		"\n"
		"Parameter 'metaid' is string, the metaid of the object to find.\n"
		"\n"
		"Returns pointer to the first object found with the given 'metaid'.\n"
		"\n"
		""},
	 { "SBasePlugin_connectToParent", _wrap_SBasePlugin_connectToParent, METH_VARARGS, "\n"
		"SBasePlugin_connectToParent(SBasePlugin self, SBase sbase)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_enablePackageInternal", _wrap_SBasePlugin_enablePackageInternal, METH_VARARGS, "\n"
		"SBasePlugin_enablePackageInternal(SBasePlugin self, string pkgURI, string pkgPrefix, bool flag)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_stripPackage", _wrap_SBasePlugin_stripPackage, METH_VARARGS, "\n"
		"SBasePlugin_stripPackage(SBasePlugin self, string pkgPrefix, bool flag) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_getSBMLDocument", _wrap_SBasePlugin_getSBMLDocument, METH_VARARGS, "\n"
		"SBasePlugin_getSBMLDocument(SBasePlugin self) -> SBMLDocument\n"
		"SBasePlugin_getSBMLDocument(SBasePlugin self) -> SBMLDocument\n"
		"\n"
		"Returns the SBMLDocument object containing this object instance.\n"
		"\n"
		"LibSBML uses the class SBMLDocument as a top-level container for\n"
		"storing SBML content and data associated with it (such as warnings and\n"
		"error messages).  An SBML model in libSBML is contained inside an\n"
		"SBMLDocument object.  SBMLDocument corresponds roughly to the class\n"
		"SBML defined in the SBML Level 3 and Level 2 specifications, but it\n"
		"does not have a direct correspondence in SBML Level 1.  (But, it is\n"
		"created by libSBML no matter whether the model is Level 1, Level 2 or\n"
		"Level 3.)\n"
		"\n"
		"This method allows the caller to obtain the SBMLDocument for the\n"
		"current object.\n"
		"\n"
		"Returns the parent SBMLDocument object of this plugin object.\n"
		"\n"
		"See also getParentSBMLObject().\n"
		"\n"
		""},
	 { "SBasePlugin_getURI", _wrap_SBasePlugin_getURI, METH_O, "\n"
		"SBasePlugin_getURI(SBasePlugin self) -> string\n"
		"\n"
		"Returns the XML namespace URI for the package to which this object\n"
		"belongs.\n"
		"\n"
		"In the XML representation of an SBML document, XML namespaces are\n"
		"used to identify the origin of each XML construct used.  XML\n"
		"namespaces are identified by their unique resource identifiers (URIs).\n"
		"The core SBML specifications stipulate the namespaces that must be\n"
		"used for core SBML constructs; for example, all XML elements that\n"
		"belong to SBML Level 3 Version 1 Core must be placed in the XML\n"
		"namespace identified by the URI\n"
		"'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML\n"
		"Level 3 packages define their own XML namespaces; for example, all\n"
		"elements belonging to the SBML Level 3 Layout Version 1 package must\n"
		"be placed in the XML namespace\n"
		"'http://www.sbml.org/sbml/level3/version1/layout/version1/'.\n"
		"\n"
		"This method first looks into the SBMLNamespaces object possessed by\n"
		"the parent SBMLDocument object of the current object.  If this cannot\n"
		"be found, this method returns the result of getElementNamespace().\n"
		"\n"
		"Returns a string, the URI of the XML namespace to which this object\n"
		"belongs.\n"
		"\n"
		"See also getPackageName(), getElementNamespace(), getSBMLDocument().\n"
		"\n"
		""},
	 { "SBasePlugin_getParentSBMLObject", _wrap_SBasePlugin_getParentSBMLObject, METH_VARARGS, "\n"
		"SBasePlugin_getParentSBMLObject(SBasePlugin self) -> SBase\n"
		"SBasePlugin_getParentSBMLObject(SBasePlugin self) -> SBase\n"
		"\n"
		"Returns the parent object to which this plugin object is connected.\n"
		"\n"
		"Returns the parent object of this object.\n"
		"\n"
		""},
	 { "SBasePlugin_setElementNamespace", _wrap_SBasePlugin_setElementNamespace, METH_VARARGS, "\n"
		"SBasePlugin_setElementNamespace(SBasePlugin self, string uri) -> int\n"
		"\n"
		"Sets the XML namespace to which this object belongs.\n"
		"\n"
		"In the XML representation of an SBML document, XML namespaces are\n"
		"used to identify the origin of each XML construct used.  XML\n"
		"namespaces are identified by their unique resource identifiers (URIs).\n"
		"The core SBML specifications stipulate the namespaces that must be\n"
		"used for core SBML constructs; for example, all XML elements that\n"
		"belong to SBML Level 3 Version 1 Core must be placed in the XML\n"
		"namespace identified by the URI\n"
		"'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML\n"
		"Level 3 packages define their own XML namespaces; for example, all\n"
		"elements belonging to the SBML Level 3 Layout Version 1 package must\n"
		"be placed in the XML namespace\n"
		"'http://www.sbml.org/sbml/level3/version1/layout/version1/'.\n"
		"\n"
		"Parameter 'uri' is the URI to assign to this object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also getElementNamespace().\n"
		"\n"
		""},
	 { "SBasePlugin_getLevel", _wrap_SBasePlugin_getLevel, METH_O, "\n"
		"SBasePlugin_getLevel(SBasePlugin self) -> unsigned int\n"
		"\n"
		"Returns the SBML Level of the package extension of this plugin object.\n"
		"\n"
		"Returns the SBML Level.\n"
		"\n"
		"See also getVersion().\n"
		"\n"
		""},
	 { "SBasePlugin_getVersion", _wrap_SBasePlugin_getVersion, METH_O, "\n"
		"SBasePlugin_getVersion(SBasePlugin self) -> unsigned int\n"
		"\n"
		"Returns the Version within the SBML Level of the package extension of\n"
		"this plugin object.\n"
		"\n"
		"Returns the SBML Version.\n"
		"\n"
		"See also getLevel().\n"
		"\n"
		""},
	 { "SBasePlugin_getPackageVersion", _wrap_SBasePlugin_getPackageVersion, METH_O, "\n"
		"SBasePlugin_getPackageVersion(SBasePlugin self) -> unsigned int\n"
		"\n"
		"Returns the package version of the package extension of this plugin\n"
		"object.\n"
		"\n"
		"Returns the package version of the package extension of this plugin\n"
		"object.\n"
		"\n"
		"See also getLevel(), getVersion().\n"
		"\n"
		""},
	 { "SBasePlugin_replaceSIDWithFunction", _wrap_SBasePlugin_replaceSIDWithFunction, METH_VARARGS, "\n"
		"SBasePlugin_replaceSIDWithFunction(SBasePlugin self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_divideAssignmentsToSIdByFunction", _wrap_SBasePlugin_divideAssignmentsToSIdByFunction, METH_VARARGS, "\n"
		"SBasePlugin_divideAssignmentsToSIdByFunction(SBasePlugin self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_multiplyAssignmentsToSIdByFunction", _wrap_SBasePlugin_multiplyAssignmentsToSIdByFunction, METH_VARARGS, "\n"
		"SBasePlugin_multiplyAssignmentsToSIdByFunction(SBasePlugin self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_hasIdentifierBeginningWith", _wrap_SBasePlugin_hasIdentifierBeginningWith, METH_VARARGS, "\n"
		"SBasePlugin_hasIdentifierBeginningWith(SBasePlugin self, string prefix) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_prependStringToAllIdentifiers", _wrap_SBasePlugin_prependStringToAllIdentifiers, METH_VARARGS, "\n"
		"SBasePlugin_prependStringToAllIdentifiers(SBasePlugin self, string prefix) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_renameSIdRefs", _wrap_SBasePlugin_renameSIdRefs, METH_VARARGS, "\n"
		"SBasePlugin_renameSIdRefs(SBasePlugin self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'SIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object identifiers are of a data type called SId. In SBML\n"
		"Level 3, an explicit data type called SIdRef was introduced for\n"
		"attribute values that refer to SId values; in previous Levels of SBML,\n"
		"this data type did not exist and attributes were simply described to\n"
		"as 'referring to an identifier', but the effective data type was the\n"
		"same as SIdRef in Level 3.  These and other methods of libSBML refer\n"
		"to the type SIdRef for all Levels of SBML, even if the corresponding\n"
		"SBML specification did not explicitly name the data type.\n"
		"\n"
		"This method works by looking at all attributes and (if appropriate)\n"
		"mathematical formulas in MathML content, comparing the referenced\n"
		"identifiers to the value of 'oldid'.  If any matches are found, the\n"
		"matching values are replaced with 'newid'.  The method does not\n"
		"descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "SBasePlugin_renameMetaIdRefs", _wrap_SBasePlugin_renameMetaIdRefs, METH_VARARGS, "\n"
		"SBasePlugin_renameMetaIdRefs(SBasePlugin self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given meta identifier attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, object 'meta' identifiers are of the XML data type ID; the\n"
		"SBML object attribute itself is typically named metaid.  All\n"
		"attributes that hold values referring to values of type ID are of the\n"
		"XML data type IDREF.  They are also sometimes informally referred to\n"
		"as 'metaid refs', in analogy to the SBML-defined type SIdRef.\n"
		"\n"
		"This method works by looking at all meta-identifier attribute values,\n"
		"comparing the identifiers to the value of 'oldid'.  If any matches are\n"
		"found, the matching identifiers are replaced with 'newid'.  The method\n"
		"does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "SBasePlugin_renameUnitSIdRefs", _wrap_SBasePlugin_renameUnitSIdRefs, METH_VARARGS, "\n"
		"SBasePlugin_renameUnitSIdRefs(SBasePlugin self, string oldid, string newid)\n"
		"\n"
		"Replaces all uses of a given 'UnitSIdRef' type attribute value with\n"
		"another value.\n"
		"\n"
		"In SBML, unit definitions have identifiers of type UnitSId.  In SBML\n"
		"Level 3, an explicit data type called UnitSIdRef was introduced for\n"
		"attribute values that refer to UnitSId values; in previous Levels of\n"
		"SBML, this data type did not exist and attributes were simply\n"
		"described to as 'referring to a unit identifier', but the effective\n"
		"data type was the same as UnitSIdRef in Level 3.  These and other\n"
		"methods of libSBML refer to the type UnitSIdRef for all Levels of\n"
		"SBML, even if the corresponding SBML specification did not explicitly\n"
		"name the data type.\n"
		"\n"
		"This method works by looking at all unit identifier attribute values\n"
		"(including, if appropriate, inside mathematical formulas), comparing\n"
		"the referenced unit identifiers to the value of 'oldid'.  If any\n"
		"matches are found, the matching values are replaced with 'newid'.  The\n"
		"method does not descend into child elements.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "SBasePlugin_transformIdentifiers", _wrap_SBasePlugin_transformIdentifiers, METH_VARARGS, "\n"
		"SBasePlugin_transformIdentifiers(SBasePlugin self, IdentifierTransformer sidTransformer) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_getLine", _wrap_SBasePlugin_getLine, METH_O, "\n"
		"SBasePlugin_getLine(SBasePlugin self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_getColumn", _wrap_SBasePlugin_getColumn, METH_O, "\n"
		"SBasePlugin_getColumn(SBasePlugin self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_getSBMLNamespaces", _wrap_SBasePlugin_getSBMLNamespaces, METH_O, "\n"
		"SBasePlugin_getSBMLNamespaces(SBasePlugin self) -> SBMLNamespaces\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_logUnknownElement", _wrap_SBasePlugin_logUnknownElement, METH_VARARGS, "\n"
		"SBasePlugin_logUnknownElement(SBasePlugin self, string element, unsigned int const sbmlLevel, unsigned int const sbmlVersion, unsigned int const pkgVersion)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_isValidTypeForList", _wrap_SBasePlugin_isValidTypeForList, METH_VARARGS, "\n"
		"SBasePlugin_isValidTypeForList(SBasePlugin self, SBase item) -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "SBasePlugin_getSBMLExtension", _wrap_SBasePlugin_getSBMLExtension, METH_O, "\n"
		"SBasePlugin_getSBMLExtension(SBasePlugin self) -> SBMLExtension\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_updateSBMLNamespace", _wrap_SBasePlugin_updateSBMLNamespace, METH_VARARGS, "\n"
		"SBasePlugin_updateSBMLNamespace(SBasePlugin self, string package, unsigned int level, unsigned int version)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBasePlugin_getListOfAllElements", _wrap_SBasePlugin_getListOfAllElements, METH_VARARGS, "\n"
		"SBasePlugin_getListOfAllElements(SBasePlugin self, ElementFilter filter=None) -> SBaseList\n"
		"\n"
		"Returns an SBaseList of all child SBase objects, including those\n"
		"nested to an arbitrary depth.\n"
		"\n"
		"@return a list of all objects that are children of this object.\n"
		"\n"
		""},
	 { "SBasePlugin_swigregister", SBasePlugin_swigregister, METH_O, NULL},
	 { "new_SBMLDocumentPlugin", _wrap_new_SBMLDocumentPlugin, METH_VARARGS, "\n"
		"SBMLDocumentPlugin(string uri, string prefix, SBMLNamespaces sbmlns)\n"
		"new_SBMLDocumentPlugin(SBMLDocumentPlugin orig) -> SBMLDocumentPlugin\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLDocumentPlugin(string &uri, string &prefix,\n"
		"SBMLNamespaces sbmlns)\n"
		"\n"
		"Creates a new SBMLDocumentPlugin object using the given parameters.\n"
		"\n"
		"In the XML representation of an SBML document, XML namespaces are\n"
		"used to identify the origin of each XML construct used.  XML\n"
		"namespaces are identified by their unique resource identifiers (URIs).\n"
		"The core SBML specifications stipulate the namespaces that must be\n"
		"used for core SBML constructs; for example, all XML elements that\n"
		"belong to SBML Level 3 Version 1 Core must be placed in the XML\n"
		"namespace identified by the URI\n"
		"'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML\n"
		"Level 3 packages define their own XML namespaces; for example, all\n"
		"elements belonging to the SBML Level 3 Layout Version 1 package must\n"
		"be placed in the XML namespace\n"
		"'http://www.sbml.org/sbml/level3/version1/layout/version1/'.\n"
		"\n"
		"The SBMLNamespaces object encapsulates SBML Level/Version/namespaces\n"
		"information.  It is used to communicate the SBML Level, Version, and\n"
		"(in Level 3) packages used in addition to SBML Level 3 Core.  A common\n"
		"approach to using libSBML's SBMLNamespaces facilities is to create an\n"
		"SBMLNamespaces object somewhere in a program once, then hand that\n"
		"object as needed to object constructors that accept SBMLNamespaces as\n"
		"arguments.\n"
		"\n"
		"Parameter 'uri' is the URI of the SBML Level 3 package implemented by\n"
		"this libSBML package extension.\n"
		"\n"
		"Parameter 'prefix' is the XML namespace prefix being used for the\n"
		"package.\n"
		"\n"
		"Parameter 'sbmlns' is the SBMLNamespaces object for the package.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    SBMLDocumentPlugin(SBMLDocumentPlugin orig)\n"
		"\n"
		"Copy constructor.\n"
		"\n"
		"This creates a copy of this object.\n"
		"\n"
		"Parameter 'orig' is the SBMLDocumentPlugin instance to copy.\n"
		"\n"
		""},
	 { "delete_SBMLDocumentPlugin", _wrap_delete_SBMLDocumentPlugin, METH_O, "delete_SBMLDocumentPlugin(SBMLDocumentPlugin self)"},
	 { "SBMLDocumentPlugin_clone", _wrap_SBMLDocumentPlugin_clone, METH_O, "\n"
		"SBMLDocumentPlugin_clone(SBMLDocumentPlugin self) -> SBMLDocumentPlugin\n"
		"\n"
		"Creates and returns a deep copy of this SBMLDocumentPlugin object.\n"
		"\n"
		"Returns the (deep) copy of this SBMLDocumentPlugin object.\n"
		"\n"
		""},
	 { "SBMLDocumentPlugin_setRequired", _wrap_SBMLDocumentPlugin_setRequired, METH_VARARGS, "\n"
		"SBMLDocumentPlugin_setRequired(SBMLDocumentPlugin self, bool value) -> int\n"
		"\n"
		"Sets the SBML 'required' attribute value.\n"
		"\n"
		"SBML Level 3 requires that every package defines an attribute named\n"
		"'required' on the root <sbml> element in an SBML file or data stream.\n"
		"The attribute, being in the namespace of the Level 3 package in\n"
		"question, must be prefixed by the XML namespace prefix associated with\n"
		"the package.  The value of the 'required' attribute indicates whether\n"
		"constructs in that package may change the mathematical interpretation\n"
		"of constructs defined in SBML Level 3 Core.  A 'required' value of\n"
		"'True' indicates that the package may do so.  The value of the\n"
		"attribute is set by the Level 3 package specification, and does not\n"
		"depend on the actual presence or absence of particular package\n"
		"constructs in a given SBML document: in other words, if the package\n"
		"specification defines any construct that can change the model's\n"
		"meaning, the value of the 'required' attribute must always be set to\n"
		"'True' in any SBML document that uses the package.\n"
		"\n"
		"The XML namespace declaration for an SBML Level 3 package is an\n"
		"indication that a model makes use of features defined by that package,\n"
		"while the 'required' attribute indicates whether the features may be\n"
		"ignored without compromising the mathematical meaning of the model.\n"
		"Both are necessary for a complete reference to an SBML Level 3\n"
		"package.\n"
		"\n"
		"Parameter 'value' is the value to be assigned to the 'required'\n"
		"attribute. The 'required' attribute takes a Boolean value, either\n"
		"'True' or 'False.'\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"See also getRequired(), isSetRequired(), unsetRequired().\n"
		"\n"
		""},
	 { "SBMLDocumentPlugin_getRequired", _wrap_SBMLDocumentPlugin_getRequired, METH_O, "\n"
		"SBMLDocumentPlugin_getRequired(SBMLDocumentPlugin self) -> bool\n"
		"\n"
		"Returns the value of the 'required' attribute.\n"
		"\n"
		"SBML Level 3 requires that every package defines an attribute named\n"
		"'required' on the root <sbml> element in an SBML file or data stream.\n"
		"The attribute, being in the namespace of the Level 3 package in\n"
		"question, must be prefixed by the XML namespace prefix associated with\n"
		"the package.  The value of the 'required' attribute indicates whether\n"
		"constructs in that package may change the mathematical interpretation\n"
		"of constructs defined in SBML Level 3 Core.  A 'required' value of\n"
		"'True' indicates that the package may do so.  The value of the\n"
		"attribute is set by the Level 3 package specification, and does not\n"
		"depend on the actual presence or absence of particular package\n"
		"constructs in a given SBML document: in other words, if the package\n"
		"specification defines any construct that can change the model's\n"
		"meaning, the value of the 'required' attribute must always be set to\n"
		"'True' in any SBML document that uses the package.\n"
		"\n"
		"The XML namespace declaration for an SBML Level 3 package is an\n"
		"indication that a model makes use of features defined by that package,\n"
		"while the 'required' attribute indicates whether the features may be\n"
		"ignored without compromising the mathematical meaning of the model.\n"
		"Both are necessary for a complete reference to an SBML Level 3\n"
		"package.\n"
		"\n"
		"Returns the bool value of 'required' attribute for the SBML package.\n"
		"\n"
		"See also setRequired(), isSetRequired(), unsetRequired().\n"
		"\n"
		""},
	 { "SBMLDocumentPlugin_isSetRequired", _wrap_SBMLDocumentPlugin_isSetRequired, METH_O, "\n"
		"SBMLDocumentPlugin_isSetRequired(SBMLDocumentPlugin self) -> bool\n"
		"\n"
		"Returns the value of the 'required' attribute.\n"
		"\n"
		"SBML Level 3 requires that every package defines an attribute named\n"
		"'required' on the root <sbml> element in an SBML file or data stream.\n"
		"The attribute, being in the namespace of the Level 3 package in\n"
		"question, must be prefixed by the XML namespace prefix associated with\n"
		"the package.  The value of the 'required' attribute indicates whether\n"
		"constructs in that package may change the mathematical interpretation\n"
		"of constructs defined in SBML Level 3 Core.  A 'required' value of\n"
		"'True' indicates that the package may do so.  The value of the\n"
		"attribute is set by the Level 3 package specification, and does not\n"
		"depend on the actual presence or absence of particular package\n"
		"constructs in a given SBML document: in other words, if the package\n"
		"specification defines any construct that can change the model's\n"
		"meaning, the value of the 'required' attribute must always be set to\n"
		"'True' in any SBML document that uses the package.\n"
		"\n"
		"The XML namespace declaration for an SBML Level 3 package is an\n"
		"indication that a model makes use of features defined by that package,\n"
		"while the 'required' attribute indicates whether the features may be\n"
		"ignored without compromising the mathematical meaning of the model.\n"
		"Both are necessary for a complete reference to an SBML Level 3\n"
		"package.\n"
		"\n"
		"Returns 'True' if the 'required' attribute of this SBMLDocument has\n"
		"been set to 'True,' 'False' otherwise.\n"
		"\n"
		""},
	 { "SBMLDocumentPlugin_unsetRequired", _wrap_SBMLDocumentPlugin_unsetRequired, METH_O, "\n"
		"SBMLDocumentPlugin_unsetRequired(SBMLDocumentPlugin self) -> int\n"
		"\n"
		"Unsets the value of the 'required' attribute of this\n"
		"SBMLDocumentPlugin.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "SBMLDocumentPlugin_isCompFlatteningImplemented", _wrap_SBMLDocumentPlugin_isCompFlatteningImplemented, METH_O, "\n"
		"SBMLDocumentPlugin_isCompFlatteningImplemented(SBMLDocumentPlugin self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocumentPlugin_checkConsistency", _wrap_SBMLDocumentPlugin_checkConsistency, METH_O, "\n"
		"SBMLDocumentPlugin_checkConsistency(SBMLDocumentPlugin self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLDocumentPlugin_swigregister", SBMLDocumentPlugin_swigregister, METH_O, NULL},
	 { "SBMLDocumentPlugin_swiginit", SBMLDocumentPlugin_swiginit, METH_VARARGS, NULL},
	 { "delete_SBMLExtension", _wrap_delete_SBMLExtension, METH_O, "delete_SBMLExtension(SBMLExtension self)"},
	 { "SBMLExtension_getNumOfSBasePlugins", _wrap_SBMLExtension_getNumOfSBasePlugins, METH_O, "\n"
		"SBMLExtension_getNumOfSBasePlugins(SBMLExtension self) -> int\n"
		"\n"
		"Returns the number of SBasePluginCreatorBase objects stored in this\n"
		"object.\n"
		"\n"
		"Returns the total number of SBasePluginCreatorBase objects stored in\n"
		"this SBMLExtension-derived object.\n"
		"\n"
		""},
	 { "SBMLExtension_getNumOfSupportedPackageURI", _wrap_SBMLExtension_getNumOfSupportedPackageURI, METH_O, "\n"
		"SBMLExtension_getNumOfSupportedPackageURI(SBMLExtension self) -> unsigned int\n"
		"\n"
		"Returns the number of supported package namespace URIs.\n"
		"\n"
		"Returns the number of supported package XML namespace URIs of this\n"
		"package extension.\n"
		"\n"
		""},
	 { "SBMLExtension_isSupported", _wrap_SBMLExtension_isSupported, METH_VARARGS, "\n"
		"SBMLExtension_isSupported(SBMLExtension self, string uri) -> bool\n"
		"\n"
		"Returns 'True' if the given XML namespace URI is supported by this\n"
		"package extension.\n"
		"\n"
		"Returns 'True' if the given XML namespace URI (equivalent to a package\n"
		"version) is supported by this package extension, 'False' otherwise.\n"
		"\n"
		""},
	 { "SBMLExtension_getSupportedPackageURI", _wrap_SBMLExtension_getSupportedPackageURI, METH_VARARGS, "\n"
		"SBMLExtension_getSupportedPackageURI(SBMLExtension self, unsigned int n) -> string\n"
		"\n"
		"Returns the nth XML namespace URI.\n"
		"\n"
		"Parameter 'n' is the index number of the namespace URI being sought.\n"
		"Returns a string representing the XML namespace URI understood to be\n"
		"supported by this package.  An empty string will be returned if there\n"
		"is no nth URI.\n"
		"\n"
		""},
	 { "SBMLExtension_clone", _wrap_SBMLExtension_clone, METH_O, "\n"
		"SBMLExtension_clone(SBMLExtension self) -> SBMLExtension\n"
		"\n"
		"Creates and returns a deep copy of this SBMLExtension object.\n"
		"\n"
		"Returns a (deep) copy of this SBMLExtension object.\n"
		"\n"
		"Note: This is a method that package extension implementations must\n"
		"override. See the libSBML documentation on extending libSBML to\n"
		"support SBML packages for more information on this topic.\n"
		"\n"
		""},
	 { "SBMLExtension_getName", _wrap_SBMLExtension_getName, METH_O, "\n"
		"SBMLExtension_getName(SBMLExtension self) -> string\n"
		"\n"
		"Returns the nickname of this package.\n"
		"\n"
		"This returns the short-form name of an SBML Level 3 package\n"
		"implemented by a given SBMLExtension-derived class.  Examples of such\n"
		"names are 'layout', 'fbc', etc.\n"
		"\n"
		"Returns a string, the nickname of SBML package.\n"
		"\n"
		"Note: This is a method that package extension implementations must\n"
		"override. See the libSBML documentation on extending libSBML to\n"
		"support SBML packages for more information on this topic.\n"
		"\n"
		""},
	 { "SBMLExtension_getURI", _wrap_SBMLExtension_getURI, METH_VARARGS, "\n"
		"SBMLExtension_getURI(SBMLExtension self, unsigned int sbmlLevel, unsigned int sbmlVersion, unsigned int pkgVersion) -> string\n"
		"\n"
		"Returns the XML namespace URI for a given Level and Version.\n"
		"\n"
		"Parameter 'sbmlLevel' is the SBML Level. Parameter 'sbmlVersion' is\n"
		"the SBML Version. Parameter 'pkgVersion' is the version of the\n"
		"package.\n"
		"\n"
		"Returns a string, the XML namespace URI for the package for the given\n"
		"SBML Level, SBML Version, and package version.\n"
		"\n"
		"Note: This is a method that package extension implementations must\n"
		"override. See the libSBML documentation on extending libSBML to\n"
		"support SBML packages for more information on this topic.\n"
		"\n"
		""},
	 { "SBMLExtension_getLevel", _wrap_SBMLExtension_getLevel, METH_VARARGS, "\n"
		"SBMLExtension_getLevel(SBMLExtension self, string uri) -> unsigned int\n"
		"\n"
		"Returns the SBML Level associated with the given XML namespace URI.\n"
		"\n"
		"Parameter 'uri' is the string of URI that represents a version of the\n"
		"package.\n"
		"\n"
		"Returns the SBML Level associated with the given URI of this package.\n"
		"\n"
		"Note: This is a method that package extension implementations must\n"
		"override. See the libSBML documentation on extending libSBML to\n"
		"support SBML packages for more information on this topic.\n"
		"\n"
		""},
	 { "SBMLExtension_getVersion", _wrap_SBMLExtension_getVersion, METH_VARARGS, "\n"
		"SBMLExtension_getVersion(SBMLExtension self, string uri) -> unsigned int\n"
		"\n"
		"Returns the SBML Version associated with the given XML namespace URI.\n"
		"\n"
		"Parameter 'uri' is the string of URI that represents a version of the\n"
		"package.\n"
		"\n"
		"Returns the SBML Version associated with the given URI of this\n"
		"package.\n"
		"\n"
		"Note: This is a method that package extension implementations must\n"
		"override. See the libSBML documentation on extending libSBML to\n"
		"support SBML packages for more information on this topic.\n"
		"\n"
		""},
	 { "SBMLExtension_getPackageVersion", _wrap_SBMLExtension_getPackageVersion, METH_VARARGS, "\n"
		"SBMLExtension_getPackageVersion(SBMLExtension self, string uri) -> unsigned int\n"
		"\n"
		"Returns the package version associated with the given XML namespace\n"
		"URI.\n"
		"\n"
		"Parameter 'uri' is the string of URI that represents a version of this\n"
		"package.\n"
		"\n"
		"Returns the package version associated with the given URI of this\n"
		"package.\n"
		"\n"
		"Note: This is a method that package extension implementations must\n"
		"override. See the libSBML documentation on extending libSBML to\n"
		"support SBML packages for more information on this topic.\n"
		"\n"
		""},
	 { "SBMLExtension_getStringFromTypeCode", _wrap_SBMLExtension_getStringFromTypeCode, METH_VARARGS, "\n"
		"SBMLExtension_getStringFromTypeCode(SBMLExtension self, int typeCode) -> char const *\n"
		"\n"
		"Returns a string representation of a type code.\n"
		"\n"
		"This method takes a numerical type code 'typeCode' for a component\n"
		"object implemented by this package extension, and returns a string\n"
		"representing that type code.\n"
		"\n"
		"Parameter 'typeCode' is the type code to turn into a string.\n"
		"\n"
		"Returns the string representation of 'typeCode'.\n"
		"\n"
		"Note: This is a method that package extension implementations must\n"
		"override. See the libSBML documentation on extending libSBML to\n"
		"support SBML packages for more information on this topic.\n"
		"\n"
		""},
	 { "SBMLExtension_getSBMLExtensionNamespaces", _wrap_SBMLExtension_getSBMLExtensionNamespaces, METH_VARARGS, "\n"
		"SBMLExtension_getSBMLExtensionNamespaces(SBMLExtension self, string uri) -> SBMLNamespaces\n"
		"\n"
		"Returns a specialized SBMLNamespaces object corresponding to a given\n"
		"namespace URI.\n"
		"\n"
		"LibSBML package extensions each define a subclass of SBMLNamespaces.\n"
		"\n"
		"The present method returns the appropriate object corresponding to the\n"
		"given XML namespace URI in argument 'uri'.\n"
		"\n"
		"Parameter 'uri' is the namespace URI that represents one of versions\n"
		"of the package implemented in this extension.\n"
		"\n"
		"Returns an SBMLNamespaces   object, or 'None' if the given 'uri' is\n"
		"not defined in the corresponding package.\n"
		"\n"
		"Note: This is a method that package extension implementations must\n"
		"override. See the libSBML documentation on extending libSBML to\n"
		"support SBML packages for more information on this topic.\n"
		"\n"
		""},
	 { "SBMLExtension_setEnabled", _wrap_SBMLExtension_setEnabled, METH_VARARGS, "\n"
		"SBMLExtension_setEnabled(SBMLExtension self, bool isEnabled) -> bool\n"
		"\n"
		"Enable or disable this package.\n"
		"\n"
		"Parameter 'isEnabled' is flag indicating whether to enable (if 'True)'\n"
		"or disable ('False)' this package extension.\n"
		"\n"
		"Returns 'True' if this call succeeded; 'False' otherwise.\n"
		"\n"
		""},
	 { "SBMLExtension_isEnabled", _wrap_SBMLExtension_isEnabled, METH_O, "\n"
		"SBMLExtension_isEnabled(SBMLExtension self) -> bool\n"
		"\n"
		"Returns 'True' if this package is enabled.\n"
		"\n"
		"Returns 'True' if this package is enabled, 'False' otherwise.\n"
		"\n"
		""},
	 { "SBMLExtension_removeL2Namespaces", _wrap_SBMLExtension_removeL2Namespaces, METH_VARARGS, "\n"
		"SBMLExtension_removeL2Namespaces(SBMLExtension self, XMLNamespaces xmlns)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExtension_addL2Namespaces", _wrap_SBMLExtension_addL2Namespaces, METH_VARARGS, "\n"
		"SBMLExtension_addL2Namespaces(SBMLExtension self, XMLNamespaces xmlns)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExtension_enableL2NamespaceForDocument", _wrap_SBMLExtension_enableL2NamespaceForDocument, METH_VARARGS, "\n"
		"SBMLExtension_enableL2NamespaceForDocument(SBMLExtension self, SBMLDocument doc)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExtension_isInUse", _wrap_SBMLExtension_isInUse, METH_VARARGS, "\n"
		"SBMLExtension_isInUse(SBMLExtension self, SBMLDocument doc) -> bool\n"
		"\n"
		"Indicates whether this extension is being used by the given\n"
		"SBMLDocument.\n"
		"\n"
		"The default implementation returns 'True.'  This means that when a\n"
		"document had this extension enabled, it will not be possible to\n"
		"convert it to SBML Level 2 as we cannot make sure that the extension\n"
		"can be converted.\n"
		"\n"
		"Parameter 'doc' is the SBML document to test.\n"
		"\n"
		"Returns a boolean indicating whether the extension is actually being\n"
		"used by the document.\n"
		"\n"
		""},
	 { "SBMLExtension_hasMutiplePackageVersions", _wrap_SBMLExtension_hasMutiplePackageVersions, METH_O, "\n"
		"SBMLExtension_hasMutiplePackageVersions(SBMLExtension self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExtension_getErrorTableIndex", _wrap_SBMLExtension_getErrorTableIndex, METH_VARARGS, "\n"
		"SBMLExtension_getErrorTableIndex(SBMLExtension self, unsigned int errorId) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExtension_getErrorIdOffset", _wrap_SBMLExtension_getErrorIdOffset, METH_O, "\n"
		"SBMLExtension_getErrorIdOffset(SBMLExtension self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExtension_getSeverity", _wrap_SBMLExtension_getSeverity, METH_VARARGS, "\n"
		"SBMLExtension_getSeverity(SBMLExtension self, unsigned int index, unsigned int pkgVersion) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExtension_getCategory", _wrap_SBMLExtension_getCategory, METH_VARARGS, "\n"
		"SBMLExtension_getCategory(SBMLExtension self, unsigned int index) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExtension_getMessage", _wrap_SBMLExtension_getMessage, METH_VARARGS, "\n"
		"SBMLExtension_getMessage(SBMLExtension self, unsigned int index, unsigned int pkgVersion, string details) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExtension_getShortMessage", _wrap_SBMLExtension_getShortMessage, METH_VARARGS, "\n"
		"SBMLExtension_getShortMessage(SBMLExtension self, unsigned int index) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "SBMLExtension_swigregister", SBMLExtension_swigregister, METH_O, NULL},
	 { "new_SBMLExtensionException", _wrap_new_SBMLExtensionException, METH_O, "\n"
		"new_SBMLExtensionException(string errmsg) -> SBMLExtensionException\n"
		"\n"
		"Creates a new SBMLExtensionException object with a given message.\n"
		"\n"
		"Parameter 'errmsg' is a string, the text of the error message to store\n"
		"with this exception.\n"
		"\n"
		""},
	 { "delete_SBMLExtensionException", _wrap_delete_SBMLExtensionException, METH_O, "delete_SBMLExtensionException(SBMLExtensionException self)"},
	 { "SBMLExtensionException_swigregister", SBMLExtensionException_swigregister, METH_O, NULL},
	 { "SBMLExtensionException_swiginit", SBMLExtensionException_swiginit, METH_VARARGS, NULL},
	 { "SBMLExtensionRegistry_getInstance", _wrap_SBMLExtensionRegistry_getInstance, METH_NOARGS, "\n"
		"SBMLExtensionRegistry_getInstance() -> SBMLExtensionRegistry\n"
		"\n"
		"Returns a singleton instance of the registry.\n"
		"\n"
		"Callers need to obtain a copy of the package extension registry before\n"
		"they can invoke its methods.  The registry is implemented as a\n"
		"singleton, and this is the method callers can use to get a copy of it.\n"
		"\n"
		"Returns the instance of the SBMLExtensionRegistry object.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_addExtension", _wrap_SBMLExtensionRegistry_addExtension, METH_VARARGS, "\n"
		"SBMLExtensionRegistry_addExtension(SBMLExtensionRegistry self, SBMLExtension ext) -> int\n"
		"\n"
		"Add the given SBMLExtension object to this SBMLExtensionRegistry.\n"
		"\n"
		"Parameter 'ext' is the SBMLExtension object to be added.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_PKG_CONFLICT\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_getExtension", _wrap_SBMLExtensionRegistry_getExtension, METH_VARARGS, "\n"
		"SBMLExtensionRegistry_getExtension(SBMLExtensionRegistry self, string package) -> SBMLExtension\n"
		"\n"
		"Returns an SBMLExtension object with the given package URI or package\n"
		"name.\n"
		"\n"
		"Parameter 'package' is a string representing the URI or name of the\n"
		"SBML package whose package extension is being sought.\n"
		"\n"
		"Returns a clone of the SBMLExtension object with the given package URI\n"
		"or name.\n"
		"\n"
		"Note: The caller is responsible for freeing the object returned.\n"
		"Since the object is a clone, freeing it will not result in the\n"
		"deletion of the original package extension object.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_removeL2Namespaces", _wrap_SBMLExtensionRegistry_removeL2Namespaces, METH_VARARGS, "\n"
		"SBMLExtensionRegistry_removeL2Namespaces(SBMLExtensionRegistry self, XMLNamespaces xmlns)\n"
		"\n"
		"Removes SBML Level 2 namespaces from the namespace list.\n"
		"\n"
		"Parameter 'xmlns' is an XMLNamespaces object listing one or more\n"
		"namespaces to be removed.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_addL2Namespaces", _wrap_SBMLExtensionRegistry_addL2Namespaces, METH_VARARGS, "\n"
		"SBMLExtensionRegistry_addL2Namespaces(SBMLExtensionRegistry self, XMLNamespaces xmlns)\n"
		"\n"
		"Adds SBML Level 2 namespaces to the namespace list.\n"
		"\n"
		"Parameter 'xmlns' is an XMLNamespaces object providing one or more\n"
		"namespaces to be added.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_enableL2NamespaceForDocument", _wrap_SBMLExtensionRegistry_enableL2NamespaceForDocument, METH_VARARGS, "\n"
		"SBMLExtensionRegistry_enableL2NamespaceForDocument(SBMLExtensionRegistry self, SBMLDocument doc)\n"
		"\n"
		"Enables package extensions that support serialization to SBML\n"
		"annotations.\n"
		"\n"
		"SBML Level 2 does not have a package mechanism in the way that SBML\n"
		"Level 3 does.  However, SBML annotations can be used to store SBML\n"
		"constructs.  In fact, a widely-used approach to developing SBML Level\n"
		"3 packages involves first using them as annotations.\n"
		"\n"
		"Parameter 'doc' is the SBMLDocument object for which this should be\n"
		"enabled.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_disableUnusedPackages", _wrap_SBMLExtensionRegistry_disableUnusedPackages, METH_VARARGS, "\n"
		"SBMLExtensionRegistry_disableUnusedPackages(SBMLExtensionRegistry self, SBMLDocument doc)\n"
		"\n"
		"Disables unused packages.\n"
		"\n"
		"This method walks through all extensions in the list of plugins of the\n"
		"given SBML document 'doc', and disables all that are not being used.\n"
		"\n"
		"Parameter 'doc' is the SBMLDocument object whose unused package\n"
		"extensions should be disabled.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_disablePackage", _wrap_SBMLExtensionRegistry_disablePackage, METH_O, "\n"
		"SBMLExtensionRegistry_disablePackage(string package)\n"
		"\n"
		"Disables the package with the given URI or name.\n"
		"\n"
		"Parameter 'package' is a string representing the URI or name of the\n"
		"SBML package whose package extension is to be disabled.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_isPackageEnabled", _wrap_SBMLExtensionRegistry_isPackageEnabled, METH_O, "\n"
		"SBMLExtensionRegistry_isPackageEnabled(string package) -> bool\n"
		"\n"
		"Returns 'True' if the named package is enabled.\n"
		"\n"
		"Parameter 'package' is the name or URI of a package to test.\n"
		"\n"
		"Returns 'True' if the package is enabled, 'False' otherwise.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_enablePackage", _wrap_SBMLExtensionRegistry_enablePackage, METH_O, "\n"
		"SBMLExtensionRegistry_enablePackage(string package)\n"
		"\n"
		"Enables the package with the given URI / name.\n"
		"\n"
		"Parameter 'package' is the name or URI of a package to enable.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_getNumExtension", _wrap_SBMLExtensionRegistry_getNumExtension, METH_VARARGS, "\n"
		"SBMLExtensionRegistry_getNumExtension(SBMLExtensionRegistry self, SBaseExtensionPoint extPoint) -> unsigned int\n"
		"\n"
		"Returns the number of extensions that have a given extension point.\n"
		"\n"
		"Parameter 'extPoint' is the SBaseExtensionPoint object.\n"
		"\n"
		"Returns the number of SBMLExtension-derived objects with the given\n"
		"extension point.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_setEnabled", _wrap_SBMLExtensionRegistry_setEnabled, METH_VARARGS, "\n"
		"SBMLExtensionRegistry_setEnabled(SBMLExtensionRegistry self, string uri, bool isEnabled) -> bool\n"
		"\n"
		"Enables or disable the package with the given URI.\n"
		"\n"
		"Parameter 'uri' is the URI of the target package. Parameter\n"
		"'isEnabled' is 'True' to enable the package, 'False' to disable.\n"
		"\n"
		"Returns 'False' if 'isEnabled' is 'False' or the given package is not\n"
		"registered, otherwise this method returns 'True.'\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_isEnabled", _wrap_SBMLExtensionRegistry_isEnabled, METH_VARARGS, "\n"
		"SBMLExtensionRegistry_isEnabled(SBMLExtensionRegistry self, string uri) -> bool\n"
		"\n"
		"Returns 'True' if the given extension is enabled.\n"
		"\n"
		"Parameter 'uri' is the URI of the target package.\n"
		"\n"
		"Returns 'False' if the given package is disabled or not registered,\n"
		"'True' otherwise.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_isRegistered", _wrap_SBMLExtensionRegistry_isRegistered, METH_VARARGS, "\n"
		"SBMLExtensionRegistry_isRegistered(SBMLExtensionRegistry self, string uri) -> bool\n"
		"\n"
		"Returns 'True' if a package extension is registered for the\n"
		"corresponding package URI.\n"
		"\n"
		"Parameter 'uri' is the URI of the target package.\n"
		"\n"
		"Returns 'True' if the package with the given URI is registered,\n"
		"otherwise returns 'False.'\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_getAllRegisteredPackageNames", _wrap_SBMLExtensionRegistry_getAllRegisteredPackageNames, METH_NOARGS, "\n"
		"SBMLExtensionRegistry_getAllRegisteredPackageNames() -> std::vector< std::string >\n"
		"\n"
		"Returns a list of registered packages.\n"
		"\n"
		"This method returns a vector of strings containing the nicknames of\n"
		"the SBML packages for which package extensions are registered with\n"
		"this copy of libSBML.  The vector will contain string objects.\n"
		"\n"
		"Returns a vector of strings of the registered package names.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_getNumRegisteredPackages", _wrap_SBMLExtensionRegistry_getNumRegisteredPackages, METH_NOARGS, "\n"
		"SBMLExtensionRegistry_getNumRegisteredPackages() -> unsigned int\n"
		"\n"
		"Returns the number of registered packages.\n"
		"\n"
		"Returns a count of the registered package extensions.\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_getRegisteredPackageName", _wrap_SBMLExtensionRegistry_getRegisteredPackageName, METH_O, "\n"
		"SBMLExtensionRegistry_getRegisteredPackageName(unsigned int index) -> string\n"
		"\n"
		"Returns the nth registered package.\n"
		"\n"
		"Parameter 'index' is zero-based index of the package name to return.\n"
		"\n"
		"Returns the package name with the given index, or 'None' if none such\n"
		"exists.\n"
		"\n"
		"See also getNumRegisteredPackages().\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_getASTPlugins", _wrap_SBMLExtensionRegistry_getASTPlugins, METH_O, "\n"
		"SBMLExtensionRegistry_getASTPlugins(SBMLExtensionRegistry self) -> std::vector< ASTBasePlugin * >\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_getNumASTPlugins", _wrap_SBMLExtensionRegistry_getNumASTPlugins, METH_O, "\n"
		"SBMLExtensionRegistry_getNumASTPlugins(SBMLExtensionRegistry self) -> unsigned int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_getASTPlugin", _wrap_SBMLExtensionRegistry_getASTPlugin, METH_VARARGS, "\n"
		"SBMLExtensionRegistry_getASTPlugin(SBMLExtensionRegistry self, unsigned int i) -> ASTBasePlugin\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "SBMLExtensionRegistry_swigregister", SBMLExtensionRegistry_swigregister, METH_O, NULL},
	 { "delete_Callback", _wrap_delete_Callback, METH_O, "delete_Callback(Callback self)"},
	 { "Callback_process", _wrap_Callback_process, METH_VARARGS, "\n"
		"Callback_process(Callback self, SBMLDocument doc) -> int\n"
		"\n"
		"The processing function to be implemented by the callback\n"
		"\n"
		"In order to stop processing return a value other than\n"
		"LIBSBML_OPERATION_SUCCESS.\n"
		"\n"
		"Returns LIBSBML_OPERATION_SUCCESS to continue the operations any other\n"
		"value to stop\n"
		"\n"
		""},
	 { "new_Callback", _wrap_new_Callback, METH_O, "new_Callback(PyObject * _self) -> Callback"},
	 { "disown_Callback", _wrap_disown_Callback, METH_O, NULL},
	 { "Callback_swigregister", Callback_swigregister, METH_O, NULL},
	 { "Callback_swiginit", Callback_swiginit, METH_VARARGS, NULL},
	 { "CallbackRegistry_invokeCallbacks", _wrap_CallbackRegistry_invokeCallbacks, METH_O, "\n"
		"CallbackRegistry_invokeCallbacks(SBMLDocument doc) -> int\n"
		"\n"
		"Invokes all registered callbacks on the given document. If the\n"
		"callbacks indicate that processing should be stopped they return a\n"
		"value other than operation success.\n"
		"\n"
		"Returns LIBSBML_OPERATION_SUCCESS to indicate that processing should\n"
		"be continued,  any other value to stop processing\n"
		"\n"
		""},
	 { "CallbackRegistry_clearCallbacks", _wrap_CallbackRegistry_clearCallbacks, METH_NOARGS, "\n"
		"CallbackRegistry_clearCallbacks()\n"
		"\n"
		"Clears all registered processing callbacks\n"
		"\n"
		""},
	 { "CallbackRegistry_addCallback", _wrap_CallbackRegistry_addCallback, METH_O, "\n"
		"CallbackRegistry_addCallback(Callback cb)\n"
		"\n"
		"Registers a new processing callback that will be called with a newly\n"
		"instantiated ModelDefinition object. This allows for all post\n"
		"processing on it that needs to happen before integrating it with the\n"
		"target document.\n"
		"\n"
		"Parameter 'cb' is the callback.\n"
		"\n"
		""},
	 { "CallbackRegistry_getNumCallbacks", _wrap_CallbackRegistry_getNumCallbacks, METH_NOARGS, "\n"
		"CallbackRegistry_getNumCallbacks() -> int\n"
		"\n"
		"Returns the number of registered callbacks.\n"
		"\n"
		""},
	 { "CallbackRegistry_removeCallback", _wrap_CallbackRegistry_removeCallback, METH_VARARGS, "\n"
		"CallbackRegistry_removeCallback(int index)\n"
		"CallbackRegistry_removeCallback(Callback cb)\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeCallback(Callback *cb)\n"
		"\n"
		"Removes the specified callback from the list of registered callbacks\n"
		"\n"
		"Parameter 'cb' is the callback to be removed.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    removeCallback(int index)\n"
		"\n"
		"Removes the callback with given index.\n"
		"\n"
		"Parameter 'index' is the index of the callback to be removed from the\n"
		"list.\n"
		"\n"
		""},
	 { "delete_CallbackRegistry", _wrap_delete_CallbackRegistry, METH_O, "delete_CallbackRegistry(CallbackRegistry self)"},
	 { "CallbackRegistry_swigregister", CallbackRegistry_swigregister, METH_O, NULL},
	 { "new_ASTNode", _wrap_new_ASTNode, METH_VARARGS, "\n"
		"ASTNode(ASTNodeType_t type=AST_UNKNOWN)\n"
		"new_ASTNode(ASTNode orig) -> ASTNode\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ASTNode(ASTNode orig)\n"
		"\n"
		"Copy constructor; creates a deep copy of the given ASTNode.\n"
		"\n"
		"Parameter 'orig' is the ASTNode to be copied.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ASTNode(Token_t *token)\n"
		"\n"
		"Creates a new ASTNode from the given Token.  The resulting ASTNode\n"
		"will contain the same data as the 'token'.\n"
		"\n"
		"Parameter 'token' is the token to use as a starting point for creating\n"
		"the ASTNode object.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    ASTNode(ASTNodeType_t type = AST_UNKNOWN)\n"
		"\n"
		"Creates and returns a new ASTNode.\n"
		"\n"
		"Unless the argument 'type' is given, the returned node will by default\n"
		"have a type of AST_UNKNOWN.  If the type isn't supplied when caling\n"
		"this constructor, the caller should set the node type to something\n"
		"else as soon as possible using ASTNode.setType().\n"
		"\n"
		"Parameter 'type' is an optional type code indicating the type of node\n"
		"to create.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "delete_ASTNode", _wrap_delete_ASTNode, METH_O, "delete_ASTNode(ASTNode self)"},
	 { "ASTNode_freeName", _wrap_ASTNode_freeName, METH_O, "\n"
		"ASTNode_freeName(ASTNode self) -> int\n"
		"\n"
		"Frees the name of this ASTNode and sets it to 'None.'\n"
		"\n"
		"This operation is only applicable to ASTNode objects corresponding to\n"
		"operators, numbers, or AST_UNKNOWN.  This  method has no effect on\n"
		"other types of nodes.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		""},
	 { "ASTNode_canonicalize", _wrap_ASTNode_canonicalize, METH_O, "\n"
		"ASTNode_canonicalize(ASTNode self) -> bool\n"
		"\n"
		"Converts this ASTNode to a canonical form and returns 'True' if\n"
		"successful, 'False' otherwise.\n"
		"\n"
		"The rules determining the canonical form conversion are as follows:\n"
		"\n"
		"* If the node type is AST_NAME and the node name matches\n"
		"''ExponentialE',' ''Pi',' ''True'' or ''False'' the node type is\n"
		"converted to the corresponding  AST_CONSTANT_X type.\n"
		"\n"
		"* If the node type is an AST_FUNCTION  and the node name matches\n"
		"an SBML (MathML) function name, logical operator name, or relational\n"
		"operator name, the node is converted to the corresponding\n"
		"AST_FUNCTION_X or AST_LOGICAL_X type.\n"
		"\n"
		"SBML Level 1 function names are searched first; thus, for example,\n"
		"canonicalizing 'log' will result in a node type of AST_FUNCTION_LN.\n"
		"(See the SBML Level 1 Version 2 Specification, Appendix C.)\n"
		"\n"
		"Sometimes, canonicalization of a node results in a structural\n"
		"conversion of the node as a result of adding a child.  For example, a\n"
		"node with the SBML Level 1 function name 'sqr' and a single child node\n"
		"(the argument) will be transformed to a node of type\n"
		"AST_FUNCTION_POWER with two children.  The first child will remain\n"
		"unchanged, but the second child will be an ASTNode of type AST_INTEGER\n"
		"and a value of 2.  The function names that result in structural\n"
		"changes are: 'log10,' 'sqr,' and 'sqrt.'\n"
		"\n"
		""},
	 { "ASTNode_addChild", _wrap_ASTNode_addChild, METH_VARARGS, "\n"
		"ASTNode_addChild(ASTNode self, ASTNode disownedChild, bool inRead=False) -> int\n"
		"\n"
		"Adds the given node as a child of this ASTNode.\n"
		"\n"
		"Child nodes are added in-order, from left to right.\n"
		"\n"
		"Parameter 'disownedChild' is the ASTNode instance to add. Parameter\n"
		"'inRead' is 'False' by default; may be set to 'True' when  reading XML\n"
		"where there may be a lambda function with no bvar arguments.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Explicitly adding, removing or replacing children of an ASTNode object\n"
		"may change the structure of the mathematical formula it represents,\n"
		"and may even render the representation invalid.  Callers need to be\n"
		"careful to use this method in the context of other operations to\n"
		"create complete and correct formulas.  The method\n"
		"ASTNode.isWellFormedASTNode() may also be useful for checking the\n"
		"results of node modifications.\n"
		"\n"
		"See also prependChild(), replaceChild(), insertChild(), removeChild(),\n"
		"isWellFormedASTNode().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "ASTNode_prependChild", _wrap_ASTNode_prependChild, METH_VARARGS, "\n"
		"ASTNode_prependChild(ASTNode self, ASTNode disownedChild) -> int\n"
		"\n"
		"Adds the given node as a child of this ASTNode.  This method adds\n"
		"child nodes from right to left.\n"
		"\n"
		"Parameter 'disownedChild' is the ASTNode instance to add. Will become\n"
		"a child of the parent node.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Explicitly adding, removing or replacing children of an ASTNode object\n"
		"may change the structure of the mathematical formula it represents,\n"
		"and may even render the representation invalid.  Callers need to be\n"
		"careful to use this method in the context of other operations to\n"
		"create complete and correct formulas.  The method\n"
		"ASTNode.isWellFormedASTNode() may also be useful for checking the\n"
		"results of node modifications.\n"
		"\n"
		"See also addChild(), replaceChild(), insertChild(), removeChild().\n"
		"\n"
		""},
	 { "ASTNode_removeChild", _wrap_ASTNode_removeChild, METH_VARARGS, "\n"
		"ASTNode_removeChild(ASTNode self, unsigned int n) -> int\n"
		"\n"
		"Removes the nth child of this ASTNode object.\n"
		"\n"
		"Parameter 'n' is long the index of the child to remove.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Explicitly adding, removing or replacing children of an ASTNode object\n"
		"may change the structure of the mathematical formula it represents,\n"
		"and may even render the representation invalid.  Callers need to be\n"
		"careful to use this method in the context of other operations to\n"
		"create complete and correct formulas.  The method\n"
		"ASTNode.isWellFormedASTNode() may also be useful for checking the\n"
		"results of node modifications.\n"
		"\n"
		"See also addChild(), prependChild(), replaceChild(), insertChild().\n"
		"\n"
		""},
	 { "ASTNode_replaceChild", _wrap_ASTNode_replaceChild, METH_VARARGS, "\n"
		"ASTNode_replaceChild(ASTNode self, unsigned int n, ASTNode disownedChild, bool delreplaced=False) -> int\n"
		"\n"
		"Replaces and optionally deletes the nth child of this ASTNode with the\n"
		"given ASTNode.\n"
		"\n"
		"Parameter 'n' is long the index of the child to replace. Parameter\n"
		"'disownedChild' is ASTNode to replace the nth child. Will become a\n"
		"child of the parent node. Parameter 'delreplaced' is Boolean\n"
		"indicating whether to delete the replaced child.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Explicitly adding, removing or replacing children of an ASTNode object\n"
		"may change the structure of the mathematical formula it represents,\n"
		"and may even render the representation invalid.  Callers need to be\n"
		"careful to use this method in the context of other operations to\n"
		"create complete and correct formulas.  The method\n"
		"ASTNode.isWellFormedASTNode() may also be useful for checking the\n"
		"results of node modifications.\n"
		"\n"
		"See also addChild(), prependChild(), insertChild(), removeChild().\n"
		"\n"
		""},
	 { "ASTNode_insertChild", _wrap_ASTNode_insertChild, METH_VARARGS, "\n"
		"ASTNode_insertChild(ASTNode self, unsigned int n, ASTNode disownedChild) -> int\n"
		"\n"
		"Inserts the given ASTNode at point n in the list of children of this\n"
		"ASTNode.\n"
		"\n"
		"Parameter 'n' is long the index of the ASTNode being added. Parameter\n"
		"'disownedChild' is ASTNode to insert as the nth child.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INDEX_EXCEEDS_SIZE\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		"WARNING:\n"
		"\n"
		"Explicitly adding, removing or replacing children of an ASTNode object\n"
		"may change the structure of the mathematical formula it represents,\n"
		"and may even render the representation invalid.  Callers need to be\n"
		"careful to use this method in the context of other operations to\n"
		"create complete and correct formulas.  The method\n"
		"ASTNode.isWellFormedASTNode() may also be useful for checking the\n"
		"results of node modifications.\n"
		"\n"
		"See also addChild(), prependChild(), replaceChild(), removeChild().\n"
		"\n"
		""},
	 { "ASTNode_deepCopy", _wrap_ASTNode_deepCopy, METH_O, "\n"
		"ASTNode_deepCopy(ASTNode self) -> ASTNode\n"
		"\n"
		"Creates a recursive copy of this node and all its children.\n"
		"\n"
		"Returns a copy of this ASTNode and all its children.  The caller owns\n"
		"the returned ASTNode and is responsible for deleting it.\n"
		"\n"
		""},
	 { "ASTNode_getChild", _wrap_ASTNode_getChild, METH_VARARGS, "\n"
		"ASTNode_getChild(ASTNode self, unsigned int n) -> ASTNode\n"
		"\n"
		"Returns the child at index n of this node.\n"
		"\n"
		"Parameter 'n' is the index of the child to get.\n"
		"\n"
		"Returns the nth child of this ASTNode or 'None' if this node has no\n"
		"nth child (n >  ASTNode.getNumChildren() - 1).\n"
		"\n"
		"See also getNumChildren(), getLeftChild(), getRightChild().\n"
		"\n"
		""},
	 { "ASTNode_getLeftChild", _wrap_ASTNode_getLeftChild, METH_O, "\n"
		"ASTNode_getLeftChild(ASTNode self) -> ASTNode\n"
		"\n"
		"Returns the left child of this node.\n"
		"\n"
		"Returns the left child of this ASTNode.  This is equivalent to calling\n"
		"ASTNode.getChild() with an argument of '0.'\n"
		"\n"
		"See also getNumChildren(), getChild(), getRightChild().\n"
		"\n"
		""},
	 { "ASTNode_getRightChild", _wrap_ASTNode_getRightChild, METH_O, "\n"
		"ASTNode_getRightChild(ASTNode self) -> ASTNode\n"
		"\n"
		"Returns the right child of this node.\n"
		"\n"
		"Returns the right child of this ASTNode, or 'None' if this node has no\n"
		"right child.  If ASTNode.getNumChildren() > 1, then this is equivalent\n"
		"to:\n"
		"\n"
		"  getChild( getNumChildren() - 1 );\n"
		"\n"
		"See also getNumChildren(), getLeftChild(), getChild().\n"
		"\n"
		""},
	 { "ASTNode_getNumChildren", _wrap_ASTNode_getNumChildren, METH_O, "\n"
		"ASTNode_getNumChildren(ASTNode self) -> unsigned int\n"
		"\n"
		"Returns the number of children of this node.\n"
		"\n"
		"Returns the number of children of this ASTNode, or 0 is this node has\n"
		"no children.\n"
		"\n"
		""},
	 { "ASTNode_addSemanticsAnnotation", _wrap_ASTNode_addSemanticsAnnotation, METH_VARARGS, "\n"
		"ASTNode_addSemanticsAnnotation(ASTNode self, XMLNode disownedAnnotation) -> int\n"
		"\n"
		"Adds the given XMLNode as a MathML <semantics> element to this\n"
		"ASTNode.\n"
		"\n"
		"The <semantics> element is a MathML 2.0 construct that can be used to\n"
		"associate additional information with a MathML construct.  The\n"
		"construct can be used to decorate a MathML expressions with a sequence\n"
		"of one or more <annotation> or <annotation-xml> elements.  Each such\n"
		"element contains a pair of items; the first is a symbol that acts as\n"
		"an attribute or key, and the second is the value associated with the\n"
		"attribute or key.  Please refer to the MathML 2.0 documentation,\n"
		"particularly the Section 5.2, Semantic Annotations for more\n"
		"information about these constructs.\n"
		"\n"
		"Parameter 'disownedAnnotation' is the annotation to add. Will become a\n"
		"child of the parent node.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"Note: Although SBML permits the use of the MathML <semantics>\n"
		"annotation construct, the truth is that this construct has so far (at\n"
		"this time of this writing, which is early 2014) seen very little use\n"
		"in SBML software.  The full implications of using these annotations\n"
		"are still poorly understood.  If you wish to use this construct, we\n"
		"urge you to discuss possible uses and applications on the SBML\n"
		"discussion lists, particularly sbml-discuss and/or sbml-\n"
		"interoperability.\n"
		"\n"
		"See also getNumSemanticsAnnotations(), getSemanticsAnnotation().\n"
		"\n"
		""},
	 { "ASTNode_getNumSemanticsAnnotations", _wrap_ASTNode_getNumSemanticsAnnotations, METH_O, "\n"
		"ASTNode_getNumSemanticsAnnotations(ASTNode self) -> unsigned int\n"
		"\n"
		"Returns the number of MathML <semantics> element elements on this\n"
		"node.\n"
		"\n"
		"The <semantics> element is a MathML 2.0 construct that can be used to\n"
		"associate additional information with a MathML construct.  The\n"
		"construct can be used to decorate a MathML expressions with a sequence\n"
		"of one or more <annotation> or <annotation-xml> elements.  Each such\n"
		"element contains a pair of items; the first is a symbol that acts as\n"
		"an attribute or key, and the second is the value associated with the\n"
		"attribute or key.  Please refer to the MathML 2.0 documentation,\n"
		"particularly the Section 5.2, Semantic Annotations for more\n"
		"information about these constructs.\n"
		"\n"
		"Returns the number of annotations of this ASTNode.\n"
		"\n"
		"Note: Although SBML permits the use of the MathML <semantics>\n"
		"annotation construct, the truth is that this construct has so far (at\n"
		"this time of this writing, which is early 2014) seen very little use\n"
		"in SBML software.  The full implications of using these annotations\n"
		"are still poorly understood.  If you wish to use this construct, we\n"
		"urge you to discuss possible uses and applications on the SBML\n"
		"discussion lists, particularly sbml-discuss and/or sbml-\n"
		"interoperability.\n"
		"\n"
		"See also addSemanticsAnnotation(), getSemanticsAnnotation().\n"
		"\n"
		""},
	 { "ASTNode_getSemanticsAnnotation", _wrap_ASTNode_getSemanticsAnnotation, METH_VARARGS, "\n"
		"ASTNode_getSemanticsAnnotation(ASTNode self, unsigned int n) -> XMLNode\n"
		"\n"
		"Returns the nth MathML <semantics> element on this ASTNode.\n"
		"\n"
		"The <semantics> element is a MathML 2.0 construct that can be used to\n"
		"associate additional information with a MathML construct.  The\n"
		"construct can be used to decorate a MathML expressions with a sequence\n"
		"of one or more <annotation> or <annotation-xml> elements.  Each such\n"
		"element contains a pair of items; the first is a symbol that acts as\n"
		"an attribute or key, and the second is the value associated with the\n"
		"attribute or key.  Please refer to the MathML 2.0 documentation,\n"
		"particularly the Section 5.2, Semantic Annotations for more\n"
		"information about these constructs.\n"
		"\n"
		"Parameter 'n' is the index of the annotation to return.  Callers\n"
		"should use ASTNode.getNumSemanticsAnnotations() to first find out how\n"
		"many annotations there are.\n"
		"\n"
		"Returns the nth annotation inside this ASTNode, or 'None' if this node\n"
		"has no nth annotation (n > ASTNode.getNumSemanticsAnnotations() - 1).\n"
		"\n"
		"Note: Although SBML permits the use of the MathML <semantics>\n"
		"annotation construct, the truth is that this construct has so far (at\n"
		"this time of this writing, which is early 2014) seen very little use\n"
		"in SBML software.  The full implications of using these annotations\n"
		"are still poorly understood.  If you wish to use this construct, we\n"
		"urge you to discuss possible uses and applications on the SBML\n"
		"discussion lists, particularly sbml-discuss and/or sbml-\n"
		"interoperability.\n"
		"\n"
		"See also getNumSemanticsAnnotations(), addSemanticsAnnotation().\n"
		"\n"
		""},
	 { "ASTNode_getCharacter", _wrap_ASTNode_getCharacter, METH_O, "\n"
		"ASTNode_getCharacter(ASTNode self) -> char\n"
		"\n"
		"Returns the value of this node as a single character.\n"
		"\n"
		"This function should be called only when ASTNode.getType() returns\n"
		"AST_PLUS, AST_MINUS, AST_TIMES, AST_DIVIDE or AST_POWER.\n"
		"\n"
		"Returns the value of this ASTNode as a single character\n"
		"\n"
		""},
	 { "ASTNode_getId", _wrap_ASTNode_getId, METH_O, "\n"
		"ASTNode_getId(ASTNode self) -> string\n"
		"\n"
		"Returns the MathML 'id' attribute value of this ASTNode.\n"
		"\n"
		"Returns the MathML id of this ASTNode.\n"
		"\n"
		"See also isSetId(), setId(), unsetId().\n"
		"\n"
		""},
	 { "ASTNode_getClass", _wrap_ASTNode_getClass, METH_O, "\n"
		"ASTNode_getClass(ASTNode self) -> string\n"
		"\n"
		"Returns the MathML 'class' attribute value of this ASTNode.\n"
		"\n"
		"Returns the MathML class of this ASTNode, or an empty string if it\n"
		"does not exist.\n"
		"\n"
		"See also isSetClass(), setClass(), unsetClass().\n"
		"\n"
		""},
	 { "ASTNode_getStyle", _wrap_ASTNode_getStyle, METH_O, "\n"
		"ASTNode_getStyle(ASTNode self) -> string\n"
		"\n"
		"Returns the MathML 'style' attribute value of this ASTNode.\n"
		"\n"
		"Returns the MathML style of this ASTNode, or an empty string if it\n"
		"does not exist.\n"
		"\n"
		"See also isSetStyle(), setStyle(), unsetStyle().\n"
		"\n"
		""},
	 { "ASTNode_getInteger", _wrap_ASTNode_getInteger, METH_O, "\n"
		"ASTNode_getInteger(ASTNode self) -> long\n"
		"\n"
		"Returns the value of this node as an integer.\n"
		"\n"
		"If this node type is AST_RATIONAL, this method returns the value of\n"
		"the numerator.\n"
		"\n"
		"Returns the value of this ASTNode as a (long) integer if type\n"
		"AST_INTEGER; the numerator if type AST_RATIONAL, and '0' otherwise.\n"
		"\n"
		"Note: This function should be called only when ASTNode.getType()\n"
		"returns AST_INTEGER or AST_RATIONAL. It will return '0' if the node\n"
		"type is not one of these, but since '0' may be a valid value for\n"
		"integer, it is important to be sure that the node type is one of the\n"
		"expected types in order to understand if '0' is the actual value.\n"
		"\n"
		"See also getNumerator(), getDenominator().\n"
		"\n"
		""},
	 { "ASTNode_getName", _wrap_ASTNode_getName, METH_O, "\n"
		"ASTNode_getName(ASTNode self) -> char const *\n"
		"\n"
		"Returns the value of this node as a string.\n"
		"\n"
		"This function may be called on nodes that (1) are not operators, i.e.,\n"
		"nodes for which ASTNode.isOperator() returns 'False,' and (2) are not\n"
		"numbers, i.e., ASTNode.isNumber() returns 'None.'\n"
		"\n"
		"Returns the value of this ASTNode as a string, or 'None' if it is a\n"
		"node that does not have a name equivalent (e.g., if it is a number).\n"
		"\n"
		""},
	 { "ASTNode_getOperatorName", _wrap_ASTNode_getOperatorName, METH_O, "\n"
		"ASTNode_getOperatorName(ASTNode self) -> char const *\n"
		"\n"
		"Returns the value of this operator node as a string.\n"
		"\n"
		"This function may be called on nodes that are operators, i.e., nodes\n"
		"for which ASTNode.isOperator() returns 'True.'\n"
		"\n"
		"Returns the name of this operator ASTNode as a string (or 'None' if\n"
		"not an operator).\n"
		"\n"
		""},
	 { "ASTNode_getNumerator", _wrap_ASTNode_getNumerator, METH_O, "\n"
		"ASTNode_getNumerator(ASTNode self) -> long\n"
		"\n"
		"Returns the value of the numerator of this node if of type\n"
		"AST_RATIONAL, or the  numerical value of the node if of type\n"
		"AST_INTEGER; '0' otherwise.\n"
		"\n"
		"This function should be called only when ASTNode.getType() returns\n"
		"AST_RATIONAL or AST_INTEGER. It will return '0' if the node type is\n"
		"another type, but since '0' may be a valid value for the denominator\n"
		"of a rational number or of an integer, it is important to be sure that\n"
		"the node type is the correct type in order to correctly interpret the\n"
		"returned value.\n"
		"\n"
		"Returns the value of the numerator of this ASTNode if AST_RATIONAL,\n"
		"the value if  AST_INTEGER, or '0' otherwise.\n"
		"\n"
		"See also getDenominator(), getInteger().\n"
		"\n"
		""},
	 { "ASTNode_getDenominator", _wrap_ASTNode_getDenominator, METH_O, "\n"
		"ASTNode_getDenominator(ASTNode self) -> long\n"
		"\n"
		"Returns the value of the denominator of this node.\n"
		"\n"
		"Returns the value of the denominator of this ASTNode, or '1' (true) if\n"
		"this node is not of type AST_RATIONAL.\n"
		"\n"
		"Note: This function should be called only when ASTNode.getType()\n"
		"returns AST_RATIONAL. It will return '1' if the node type is another\n"
		"type, but since '1' may be a valid value for the denominator of a\n"
		"rational number, it is important to be sure that the node type is the\n"
		"correct type in order to correctly interpret the returned value.\n"
		"\n"
		"See also getNumerator().\n"
		"\n"
		""},
	 { "ASTNode_getReal", _wrap_ASTNode_getReal, METH_O, "\n"
		"ASTNode_getReal(ASTNode self) -> double\n"
		"\n"
		"Returns the real-numbered value of this node.\n"
		"\n"
		"This function performs the necessary arithmetic if the node type is\n"
		"AST_REAL_E (mantissa * 10^exponent) or AST_RATIONAL (numerator /\n"
		"denominator).\n"
		"\n"
		"Returns the value of this ASTNode as a real (double), or '0' if this\n"
		"is not a node that holds a number.\n"
		"\n"
		"Note: This function should be called only when this ASTNode has a\n"
		"numerical value type.  It will return '0' if the node type is another\n"
		"type, but since '0' may be a valid value, it is important to be sure\n"
		"that the node type is the correct type in order to correctly interpret\n"
		"the returned value.\n"
		"\n"
		""},
	 { "ASTNode_getMantissa", _wrap_ASTNode_getMantissa, METH_O, "\n"
		"ASTNode_getMantissa(ASTNode self) -> double\n"
		"\n"
		"Returns the mantissa value of this node.\n"
		"\n"
		"If ASTNode.getType() returns AST_REAL, this method is identical to\n"
		"ASTNode.getReal().\n"
		"\n"
		"Returns the value of the mantissa of this ASTNode, or '0' if this node\n"
		"is not a type that has a real-numbered value.\n"
		"\n"
		"Note: This function should be called only when ASTNode.getType()\n"
		"returns AST_REAL_E, AST_REAL or AST_NAME_AVOGADRO.  It will return '0'\n"
		"if the node type is another type, but since '0' may be a valid value,\n"
		"it is important to be sure that the node type is the correct type in\n"
		"order to correctly interpret the returned value.\n"
		"\n"
		"See also getExponent().\n"
		"\n"
		""},
	 { "ASTNode_getExponent", _wrap_ASTNode_getExponent, METH_O, "\n"
		"ASTNode_getExponent(ASTNode self) -> long\n"
		"\n"
		"Returns the exponent value of this ASTNode.\n"
		"\n"
		"Returns the value of the exponent of this ASTNode, or '0' if this is\n"
		"not a type of node that has an exponent.\n"
		"\n"
		"Note: This function should be called only when ASTNode.getType()\n"
		"returns AST_REAL_E. It will return '0' if the node type is another\n"
		"type, but since '0' may be a valid value, it is important to be sure\n"
		"that the node type is the correct type in order to correctly interpret\n"
		"the returned value.\n"
		"\n"
		"See also getMantissa().\n"
		"\n"
		""},
	 { "ASTNode_getValue", _wrap_ASTNode_getValue, METH_O, "\n"
		"ASTNode_getValue(ASTNode self) -> double\n"
		"\n"
		"Returns the numerical value of this ASTNode.\n"
		"\n"
		"Returns the numerical value of this ASTNode, or 'NaN' if this is not a\n"
		"type of node that has a numerical value.\n"
		"\n"
		"Note: This function will return a numerical value (as a double) for\n"
		"any ASTNode_t that represents a number, a constant such as\n"
		"AST_CONSTANT_PI,  AST_CONSTANT_E, or  AST_NAME_AVOGADRO, or  '1' for\n"
		"nodes of type  AST_CONSTANT_TRUE and '0' for nodes of type\n"
		"AST_CONSTANT_FALSE. It does not evaluate the node in any way so, for\n"
		"example, it will not return the value of  a named ASTNode_t or attempt\n"
		"to evaluate a function.  This includes a node representing 'time' i.e.\n"
		"nodes of type AST_NAME_TIME.\n"
		"\n"
		""},
	 { "ASTNode_getPrecedence", _wrap_ASTNode_getPrecedence, METH_O, "\n"
		"ASTNode_getPrecedence(ASTNode self) -> int\n"
		"\n"
		"Returns the precedence of this node in the infix math syntax of SBML\n"
		"Level 1.  For more information about the infix syntax, see the\n"
		"discussion about text string formulas at the top of the documentation\n"
		"for ASTNode.\n"
		"\n"
		"Returns an integer indicating the precedence of this ASTNode\n"
		"\n"
		""},
	 { "ASTNode_getType", _wrap_ASTNode_getType, METH_O, "\n"
		"ASTNode_getType(ASTNode self) -> ASTNodeType_t\n"
		"\n"
		"Returns the type of this ASTNode.\n"
		"\n"
		"The value returned is one of the Core AST type codes such as\n"
		"AST_LAMBDA, AST_PLUS, etc.\n"
		"\n"
		"Returns the type of this ASTNode.\n"
		"\n"
		""},
	 { "ASTNode_getUnits", _wrap_ASTNode_getUnits, METH_O, "\n"
		"ASTNode_getUnits(ASTNode self) -> string\n"
		"\n"
		"Returns the units of this ASTNode.\n"
		"\n"
		"SBML Level 3 Version 1 introduced the ability to include an attribute\n"
		"sbml:units on MathML cn elements appearing in SBML mathematical\n"
		"formulas.  The value of this attribute can be used to indicate the\n"
		"unit of measurement to be associated with the number in the content of\n"
		"the cn element.  The value of this attribute must be the identifier of\n"
		"a unit of measurement defined by SBML or the enclosing Model.  Here,\n"
		"the sbml portion is an XML namespace prefix that must be associated\n"
		"with the SBML namespace for SBML Level 3.  The following example\n"
		"illustrates how this attribute can be used to define a number with\n"
		"value 10 and unit of measurement second:\n"
		"\n"
		"  <math xmlns=\"http://www.w3.org/1998/Math/MathML\"\n"
		"        xmlns:sbml=\"http://www.sbml.org/sbml/level3/version1/core\">\n"
		"          <cn type=\"integer\" sbml:units=\"second\"> 10 </cn>\n"
		"  </math>\n"
		"\n"
		"Returns the units of this ASTNode.\n"
		"\n"
		"Note: The sbml:units attribute is only available in SBML Level 3.  It\n"
		"may not be used in Levels 1-2 of SBML.\n"
		"\n"
		"See also parseL3Formula().\n"
		"\n"
		""},
	 { "ASTNode_isAvogadro", _wrap_ASTNode_isAvogadro, METH_O, "\n"
		"ASTNode_isAvogadro(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node is the special  symbol\n"
		"'avogadro.'  The predicate returns 'False' (zero) otherwise.\n"
		"\n"
		"SBML Level 3 introduced a predefined MathML <csymbol> for the value of\n"
		"Avogadro's constant.  LibSBML stores this internally as a node of type\n"
		"AST_NAME_AVOGADRO. This method returns 'True' if this node has that\n"
		"type.\n"
		"\n"
		"Returns 'True' if this ASTNode is the special symbol avogadro, 'False'\n"
		"otherwise.\n"
		"\n"
		"See also parseL3Formula().\n"
		"\n"
		""},
	 { "ASTNode_isBoolean", _wrap_ASTNode_isBoolean, METH_O, "\n"
		"ASTNode_isBoolean(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' if this node has a Boolean type.\n"
		"\n"
		"The ASTNode objects that have Boolean types are the logical operators,\n"
		"relational operators, and the constants 'True' or 'False.'\n"
		"\n"
		"Returns 'True' if this ASTNode has a Boolean type, 'False' otherwise.\n"
		"\n"
		""},
	 { "ASTNode_returnsBoolean", _wrap_ASTNode_returnsBoolean, METH_VARARGS, "\n"
		"ASTNode_returnsBoolean(ASTNode self, Model model=None) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node returns a Boolean type or\n"
		"'False' (zero) otherwise.\n"
		"\n"
		"This function looks at the whole ASTNode rather than just the top\n"
		"level of the ASTNode. Thus it will consider return values from\n"
		"piecewise statements.  In addition, if this ASTNode uses a function\n"
		"call, the return value of the functionDefinition will be determined.\n"
		"Note that this is only possible where the ASTNode can trace its parent\n"
		"Model, that is, the ASTNode must represent the <math> element of some\n"
		"SBML object that has already been added to an instance of an\n"
		"SBMLDocument. If this is not the case, this function will return\n"
		"'False' unless isBoolean() returns 'True.'\n"
		"\n"
		"See also isBoolean().\n"
		"\n"
		"Returns 'True' if this ASTNode returns a Boolean, 'False' otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isConstant", _wrap_ASTNode_isConstant, METH_O, "\n"
		"ASTNode_isConstant(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node represents a MathML constant\n"
		"(e.g., 'True,' 'Pi).'\n"
		"\n"
		"Returns 'True' if this ASTNode is a MathML constant, 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: this function will also return 'True' for nodes of type\n"
		"AST_NAME_AVOGADRO in SBML Level 3.\n"
		"\n"
		""},
	 { "ASTNode_isCiNumber", _wrap_ASTNode_isCiNumber, METH_O, "\n"
		"ASTNode_isCiNumber(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node represents a MathML ci element\n"
		"representing a value not a function (e.g., 'True,' 'Pi).'\n"
		"\n"
		"Returns 'True' if this ASTNode is a MathML ci element, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isConstantNumber", _wrap_ASTNode_isConstantNumber, METH_O, "\n"
		"ASTNode_isConstantNumber(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node represents a MathML constant\n"
		"with numeric value (e.g., 'Pi).'\n"
		"\n"
		"Returns 'True' if this ASTNode is a MathML constant, 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: this function will also return 'True' for  AST_NAME_AVOGADRO in\n"
		"SBML Level 3.\n"
		"\n"
		""},
	 { "ASTNode_isCSymbolFunction", _wrap_ASTNode_isCSymbolFunction, METH_O, "\n"
		"ASTNode_isCSymbolFunction(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node represents a MathML csymbol\n"
		"representing a function.\n"
		"\n"
		"Returns 'True' if this ASTNode is a MathML csymbol function, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isFunction", _wrap_ASTNode_isFunction, METH_O, "\n"
		"ASTNode_isFunction(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' if this node represents a function.\n"
		"\n"
		"The three types of functions in SBML are MathML functions (e.g.,\n"
		"abs()), SBML Level 1 functions (in the SBML Level 1 math syntax), and\n"
		"user-defined functions (using FunctionDefinition in SBML Level 2 and\n"
		"3).\n"
		"\n"
		"Returns 'True' if this ASTNode is a function, 'False' otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isInfinity", _wrap_ASTNode_isInfinity, METH_O, "\n"
		"ASTNode_isInfinity(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node represents the special IEEE 754\n"
		"value infinity, 'False' (zero) otherwise.\n"
		"\n"
		"Returns 'True' if this ASTNode is the special IEEE 754 value infinity,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isInteger", _wrap_ASTNode_isInteger, METH_O, "\n"
		"ASTNode_isInteger(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node contains an integer value,\n"
		"'False' (zero) otherwise.\n"
		"\n"
		"Returns 'True' if this ASTNode is of type AST_INTEGER, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isLambda", _wrap_ASTNode_isLambda, METH_O, "\n"
		"ASTNode_isLambda(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node is a MathML <lambda>, 'False'\n"
		"(zero) otherwise.\n"
		"\n"
		"Returns 'True' if this ASTNode is of type AST_LAMBDA, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isLog10", _wrap_ASTNode_isLog10, METH_O, "\n"
		"ASTNode_isLog10(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node represents a  'log10' function,\n"
		"'False' (zero) otherwise.\n"
		"\n"
		"More precisely, this predicate returns 'True' if the node type is\n"
		"AST_FUNCTION_LOG with two children, the first of which is an\n"
		"AST_INTEGER equal to 10.\n"
		"\n"
		"Returns 'True' if the given ASTNode represents a log10() function,\n"
		"'False' otherwise.\n"
		"\n"
		"See also parseL3Formula().\n"
		"\n"
		""},
	 { "ASTNode_isLogical", _wrap_ASTNode_isLogical, METH_O, "\n"
		"ASTNode_isLogical(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node is a MathML logical operator.\n"
		"\n"
		"The possible MathML logical operators in SBML core are 'and,' 'or,'\n"
		"'not,' 'xor,' and (as of SBML Level 3 Version 2) 'implies.'  If the\n"
		"node represents a logical operator defined in a Level 3 package, it\n"
		"will also return 'True.'\n"
		"\n"
		"Returns 'True' if this ASTNode is a MathML logical operator, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isName", _wrap_ASTNode_isName, METH_O, "\n"
		"ASTNode_isName(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' if this node is a user-defined variable name or the\n"
		"symbols for time or Avogadro's constant.\n"
		"\n"
		"SBML Levels 2 and 3 provides <csymbol> definitions for 'time' and\n"
		"'avogadro', which can be used to represent simulation time and\n"
		"Avogadro's constant in MathML.  Note that this method does not return\n"
		"'True' for the other csymbol values defined by SBML, 'delay', because\n"
		"the 'delay' is a function and not a constant or variable.  Similarly,\n"
		"this function returns 'False' for the csymbol functions added by the\n"
		"'Distributions' package.\n"
		"\n"
		"Returns 'True' if this ASTNode is a user-defined variable name in SBML\n"
		"or the special symbols for time or Avogadro's constant. It returns\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isNaN", _wrap_ASTNode_isNaN, METH_O, "\n"
		"ASTNode_isNaN(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node represents the special IEEE 754\n"
		"value 'not a number' (NaN), 'False' (zero) otherwise.\n"
		"\n"
		"Returns 'True' if this ASTNode is the special IEEE 754 NaN, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isNegInfinity", _wrap_ASTNode_isNegInfinity, METH_O, "\n"
		"ASTNode_isNegInfinity(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node represents the special IEEE 754\n"
		"value 'negative infinity', 'False' (zero) otherwise.\n"
		"\n"
		"Returns 'True' if this ASTNode is the special IEEE 754 value negative\n"
		"infinity, 'False' otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isNumber", _wrap_ASTNode_isNumber, METH_O, "\n"
		"ASTNode_isNumber(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node contains a number, 'False'\n"
		"(zero) otherwise.  This is functionally equivalent to the following\n"
		"code:\n"
		"\n"
		"   isInteger() || isReal()\n"
		"\n"
		"Returns 'True' if this ASTNode is a number, 'False' otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isOperator", _wrap_ASTNode_isOperator, METH_O, "\n"
		"ASTNode_isOperator(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' if this node is a mathematical operator.\n"
		"\n"
		"The possible mathematical operators in the MathML syntax supported by\n"
		"SBML are +, -, *, / and ^ (power).\n"
		"\n"
		"Returns 'True' if this ASTNode is an operator, 'False' otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isPiecewise", _wrap_ASTNode_isPiecewise, METH_O, "\n"
		"ASTNode_isPiecewise(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node is the MathML <piecewise>\n"
		"construct.\n"
		"\n"
		"Returns 'True' if this ASTNode is a MathML 'piecewise' function,\n"
		"'False' (zero) otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isRational", _wrap_ASTNode_isRational, METH_O, "\n"
		"ASTNode_isRational(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node represents a rational number.\n"
		"\n"
		"Returns 'True' if this ASTNode is of type  AST_RATIONAL, 'False'\n"
		"(zero) otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isReal", _wrap_ASTNode_isReal, METH_O, "\n"
		"ASTNode_isReal(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node can represent a real number,\n"
		"'False' (zero) otherwise.\n"
		"\n"
		"More precisely, this node must be of one of the following types:\n"
		"AST_REAL, AST_REAL_E or AST_RATIONAL.\n"
		"\n"
		"Returns 'True' if the value of this ASTNode can represented as a real\n"
		"number, 'False' otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isRelational", _wrap_ASTNode_isRelational, METH_O, "\n"
		"ASTNode_isRelational(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' if this node is a MathML relational operator.\n"
		"\n"
		"The MathML relational operators are ==, >=, >, <, and !=.\n"
		"\n"
		"Returns 'True' if this ASTNode is a MathML relational operator,\n"
		"'False' otherwise\n"
		"\n"
		""},
	 { "ASTNode_isSqrt", _wrap_ASTNode_isSqrt, METH_O, "\n"
		"ASTNode_isSqrt(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node represents a square root\n"
		"function, 'False' (zero) otherwise.\n"
		"\n"
		"More precisely, the node type must be AST_FUNCTION_ROOT with two\n"
		"children, the first of which is an AST_INTEGER node having value equal\n"
		"to 2.\n"
		"\n"
		"Returns 'True' if the given ASTNode represents a sqrt() function,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isUMinus", _wrap_ASTNode_isUMinus, METH_O, "\n"
		"ASTNode_isUMinus(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node is a unary minus operator,\n"
		"'False' (zero) otherwise.\n"
		"\n"
		"A node is defined as a unary minus node if it is of type AST_MINUS and\n"
		"has exactly one child.\n"
		"\n"
		"For numbers, unary minus nodes can be 'collapsed' by negating the\n"
		"number.  In fact, parseFormula()  does this during its parsing\n"
		"process, and parseL3Formula()  has a configuration option that allows\n"
		"this behavior to be turned on or off.  However, unary minus nodes for\n"
		"symbols (AST_NAME) cannot be 'collapsed', so this predicate function\n"
		"is necessary.\n"
		"\n"
		"Returns 'True' if this ASTNode is a unary minus, 'False' otherwise.\n"
		"\n"
		"See also parseL3Formula().\n"
		"\n"
		""},
	 { "ASTNode_isUPlus", _wrap_ASTNode_isUPlus, METH_O, "\n"
		"ASTNode_isUPlus(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node is a unary plus operator,\n"
		"'False' (zero) otherwise.  A node is defined as a unary minus node if\n"
		"it is of type AST_MINUS and has exactly one child.\n"
		"\n"
		"Returns 'True' if this ASTNode is a unary plus, 'False' otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isUserFunction", _wrap_ASTNode_isUserFunction, METH_O, "\n"
		"ASTNode_isUserFunction(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node represents a MathML user-defined\n"
		"function.\n"
		"\n"
		"Returns 'True' if this ASTNode is a user-defined function, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ASTNode_hasTypeAndNumChildren", _wrap_ASTNode_hasTypeAndNumChildren, METH_VARARGS, "\n"
		"ASTNode_hasTypeAndNumChildren(ASTNode self, ASTNodeType_t type, unsigned int numchildren) -> int\n"
		"\n"
		"Returns 'True' if this node is of type 'type' and has 'numchildren'\n"
		"number of children.  Designed for use in cases where it is useful to\n"
		"discover if the node is a unary not or unary minus, or a times node\n"
		"with no children, etc.\n"
		"\n"
		"Returns 'True' if this ASTNode is has the specified type and number of\n"
		"children, 'False' otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isUnknown", _wrap_ASTNode_isUnknown, METH_O, "\n"
		"ASTNode_isUnknown(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node has an unknown type.\n"
		"\n"
		"'Unknown' nodes have the type AST_UNKNOWN.   Nodes with unknown types\n"
		"will not appear in an ASTNode tree returned by libSBML based upon\n"
		"valid SBML input; the only situation in which a node with type\n"
		"AST_UNKNOWN  may appear is immediately after having create a new,\n"
		"untyped node using the ASTNode constructor.  Callers creating nodes\n"
		"should endeavor to set the type to a valid node type as soon as\n"
		"possible after creating new nodes.\n"
		"\n"
		"Returns 'True' if this ASTNode is of type AST_UNKNOWN, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isSetId", _wrap_ASTNode_isSetId, METH_O, "\n"
		"ASTNode_isSetId(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node has a value for the MathML\n"
		"attribute 'id'.\n"
		"\n"
		"Returns 'True' if this ASTNode has an attribute id, 'False' otherwise.\n"
		"\n"
		"See also isSetClass(), isSetStyle(), setId(), unsetId().\n"
		"\n"
		""},
	 { "ASTNode_isSetClass", _wrap_ASTNode_isSetClass, METH_O, "\n"
		"ASTNode_isSetClass(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node has a value for the MathML\n"
		"attribute 'class'.\n"
		"\n"
		"Returns 'True' if this ASTNode has an attribute class, 'False'\n"
		"otherwise.\n"
		"\n"
		"See also isSetId(), isSetStyle(), setClass(), unsetClass().\n"
		"\n"
		""},
	 { "ASTNode_isSetStyle", _wrap_ASTNode_isSetStyle, METH_O, "\n"
		"ASTNode_isSetStyle(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node has a value for the MathML\n"
		"attribute 'style'.\n"
		"\n"
		"Returns 'True' if this ASTNode has an attribute style, 'False'\n"
		"otherwise.\n"
		"\n"
		"See also isSetClass(), isSetId(), setStyle(), unsetStyle().\n"
		"\n"
		""},
	 { "ASTNode_isSetUnits", _wrap_ASTNode_isSetUnits, METH_O, "\n"
		"ASTNode_isSetUnits(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node has the attribute sbml:units.\n"
		"\n"
		"SBML Level 3 Version 1 introduced the ability to include an attribute\n"
		"sbml:units on MathML cn elements appearing in SBML mathematical\n"
		"formulas.  The value of this attribute can be used to indicate the\n"
		"unit of measurement to be associated with the number in the content of\n"
		"the cn element.  The value of this attribute must be the identifier of\n"
		"a unit of measurement defined by SBML or the enclosing Model.  Here,\n"
		"the sbml portion is an XML namespace prefix that must be associated\n"
		"with the SBML namespace for SBML Level 3.  The following example\n"
		"illustrates how this attribute can be used to define a number with\n"
		"value 10 and unit of measurement second:\n"
		"\n"
		"  <math xmlns=\"http://www.w3.org/1998/Math/MathML\"\n"
		"        xmlns:sbml=\"http://www.sbml.org/sbml/level3/version1/core\">\n"
		"          <cn type=\"integer\" sbml:units=\"second\"> 10 </cn>\n"
		"  </math>\n"
		"\n"
		"Returns 'True' if this ASTNode has units associated with it, 'False'\n"
		"otherwise.\n"
		"\n"
		"Note: The sbml:units attribute is only available in SBML Level 3.  It\n"
		"may not be used in Levels 1-2 of SBML.\n"
		"\n"
		"See also hasUnits(), setUnits().\n"
		"\n"
		""},
	 { "ASTNode_hasUnits", _wrap_ASTNode_hasUnits, METH_O, "\n"
		"ASTNode_hasUnits(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' (nonzero) if this node or any of its children nodes\n"
		"have the attribute sbml:units.\n"
		"\n"
		"SBML Level 3 Version 1 introduced the ability to include an attribute\n"
		"sbml:units on MathML cn elements appearing in SBML mathematical\n"
		"formulas.  The value of this attribute can be used to indicate the\n"
		"unit of measurement to be associated with the number in the content of\n"
		"the cn element.  The value of this attribute must be the identifier of\n"
		"a unit of measurement defined by SBML or the enclosing Model.  Here,\n"
		"the sbml portion is an XML namespace prefix that must be associated\n"
		"with the SBML namespace for SBML Level 3.  The following example\n"
		"illustrates how this attribute can be used to define a number with\n"
		"value 10 and unit of measurement second:\n"
		"\n"
		"  <math xmlns=\"http://www.w3.org/1998/Math/MathML\"\n"
		"        xmlns:sbml=\"http://www.sbml.org/sbml/level3/version1/core\">\n"
		"          <cn type=\"integer\" sbml:units=\"second\"> 10 </cn>\n"
		"  </math>\n"
		"\n"
		"Returns 'True' if this ASTNode or its children has units associated\n"
		"with it, 'False' otherwise.\n"
		"\n"
		"Note: The sbml:units attribute is only available in SBML Level 3.  It\n"
		"may not be used in Levels 1-2 of SBML.\n"
		"\n"
		"See also isSetUnits(), setUnits().\n"
		"\n"
		""},
	 { "ASTNode_setCharacter", _wrap_ASTNode_setCharacter, METH_VARARGS, "\n"
		"ASTNode_setCharacter(ASTNode self, char value) -> int\n"
		"\n"
		"Sets the value of this ASTNode to the given character.  If character\n"
		"is one of '+,' '-,' *, / or '^,' the node type will be set\n"
		"accordingly.  For all other characters, the node type will be set to\n"
		"AST_UNKNOWN.\n"
		"\n"
		"Parameter 'value' is the character value to which the node's value\n"
		"should be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "ASTNode_setId", _wrap_ASTNode_setId, METH_VARARGS, "\n"
		"ASTNode_setId(ASTNode self, string id) -> int\n"
		"\n"
		"Sets the MathML attribute 'id' of this ASTNode.\n"
		"\n"
		"Parameter 'id' is 'string' representing the identifier.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also isSetId(), getId(), unsetId().\n"
		"\n"
		""},
	 { "ASTNode_setClass", _wrap_ASTNode_setClass, METH_VARARGS, "\n"
		"ASTNode_setClass(ASTNode self, string className) -> int\n"
		"\n"
		"Sets the MathML attribute 'class' of this ASTNode to 'className'.\n"
		"\n"
		"Parameter 'className' is 'string' representing the MathML class for\n"
		"this node.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also isSetClass(), getClass(), unsetClass().\n"
		"\n"
		""},
	 { "ASTNode_setStyle", _wrap_ASTNode_setStyle, METH_VARARGS, "\n"
		"ASTNode_setStyle(ASTNode self, string style) -> int\n"
		"\n"
		"Sets the MathML attribute 'style' of this ASTNode to style.\n"
		"\n"
		"Parameter 'style' is 'string' representing the identifier.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"See also isSetStyle(), getStyle(), unsetStyle().\n"
		"\n"
		""},
	 { "ASTNode_setName", _wrap_ASTNode_setName, METH_VARARGS, "\n"
		"ASTNode_setName(ASTNode self, char const * name) -> int\n"
		"\n"
		"Sets the value of this ASTNode to the given name.\n"
		"\n"
		"As a side effect, this ASTNode object's type will be reset to AST_NAME\n"
		"if (and only if) the ASTNode was previously an operator (\n"
		"ASTNode.isOperator() == true), number ( ASTNode.isNumber() == true),\n"
		"or unknown. This allows names to be set for AST_FUNCTION nodes and the\n"
		"like.\n"
		"\n"
		"Parameter 'name' is the string containing the name to which this\n"
		"node's value should be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "ASTNode_setValue", _wrap_ASTNode_setValue, METH_VARARGS, "\n"
		"ASTNode_setValue(ASTNode self, long value) -> int\n"
		"ASTNode_setValue(ASTNode self, long numerator, long denominator) -> int\n"
		"ASTNode_setValue(ASTNode self, double value) -> int\n"
		"ASTNode_setValue(ASTNode self, double mantissa, long exponent) -> int\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setValue(long numerator, long denominator)\n"
		"\n"
		"Sets the value of this ASTNode to the given rational in two parts: the\n"
		"numerator and denominator.  The node type is set to AST_RATIONAL.\n"
		"\n"
		"Parameter 'numerator' is the numerator value of the rational.\n"
		"Parameter 'denominator' is the denominator value of the rational.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setValue(double mantissa, long exponent)\n"
		"\n"
		"Sets the value of this ASTNode to the given real ('float)' in two\n"
		"parts: the mantissa and the exponent.  The node type is set to\n"
		"AST_REAL_E.\n"
		"\n"
		"Parameter 'mantissa' is the mantissa of this node's real-numbered\n"
		"value. Parameter 'exponent' is the exponent of this node's real-\n"
		"numbered value.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setValue(int value)\n"
		"\n"
		"Sets the value of this ASTNode to the given integer and sets the node\n"
		"type to AST_INTEGER.\n"
		"\n"
		"Parameter 'value' is the integer to which this node's value should be\n"
		"set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setValue(double value)\n"
		"\n"
		"Sets the value of this ASTNode to the given real ('float)' and sets\n"
		"the node type to AST_REAL.\n"
		"\n"
		"This is functionally equivalent to:\n"
		"\n"
		"  setValue(value, 0);\n"
		"\n"
		"Parameter 'value' is the 'float' format number to which this node's\n"
		"value should be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    setValue(long value)\n"
		"\n"
		"Sets the value of this ASTNode to the given ('long)' integer and sets\n"
		"the node type to AST_INTEGER.\n"
		"\n"
		"Parameter 'value' is the integer to which this node's value should be\n"
		"set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"This particular function only does one thing irrespective of user\n"
		"input or  object state, and thus will only return a single value:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		""},
	 { "ASTNode_setType", _wrap_ASTNode_setType, METH_VARARGS, "\n"
		"ASTNode_setType(ASTNode self, ASTNodeType_t type) -> int\n"
		"\n"
		"Sets the type of this ASTNode to the given type code.\n"
		"\n"
		"Parameter 'type' is the type to which this node should be set.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: A side-effect of doing this is that any numerical values\n"
		"previously stored in this node are reset to zero.\n"
		"\n"
		""},
	 { "ASTNode_setUnits", _wrap_ASTNode_setUnits, METH_VARARGS, "\n"
		"ASTNode_setUnits(ASTNode self, string units) -> int\n"
		"\n"
		"Sets the units of this ASTNode to units.\n"
		"\n"
		"The units will be set only if this ASTNode object represents a MathML\n"
		"<cn> element, i.e., represents a number. Callers may use\n"
		"ASTNode.isNumber() to inquire whether the node is of that type.\n"
		"\n"
		"SBML Level 3 Version 1 introduced the ability to include an attribute\n"
		"sbml:units on MathML cn elements appearing in SBML mathematical\n"
		"formulas.  The value of this attribute can be used to indicate the\n"
		"unit of measurement to be associated with the number in the content of\n"
		"the cn element.  The value of this attribute must be the identifier of\n"
		"a unit of measurement defined by SBML or the enclosing Model.  Here,\n"
		"the sbml portion is an XML namespace prefix that must be associated\n"
		"with the SBML namespace for SBML Level 3.  The following example\n"
		"illustrates how this attribute can be used to define a number with\n"
		"value 10 and unit of measurement second:\n"
		"\n"
		"  <math xmlns=\"http://www.w3.org/1998/Math/MathML\"\n"
		"        xmlns:sbml=\"http://www.sbml.org/sbml/level3/version1/core\">\n"
		"          <cn type=\"integer\" sbml:units=\"second\"> 10 </cn>\n"
		"  </math>\n"
		"\n"
		"Parameter 'units' is 'string' representing the unit identifier.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_INVALID_ATTRIBUTE_VALUE\n"
		"\n"
		"Note: The sbml:units attribute is only available in SBML Level 3.  It\n"
		"may not be used in Levels 1-2 of SBML.\n"
		"\n"
		"See also isSetUnits(), hasUnits().\n"
		"\n"
		""},
	 { "ASTNode_swapChildren", _wrap_ASTNode_swapChildren, METH_VARARGS, "\n"
		"ASTNode_swapChildren(ASTNode self, ASTNode that) -> int\n"
		"\n"
		"Swaps the children of this ASTNode object with the children of the\n"
		"given ASTNode object.\n"
		"\n"
		"Parameter 'that' is the other node whose children should be used to\n"
		"replace this node's children.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "ASTNode_renameSIdRefs", _wrap_ASTNode_renameSIdRefs, METH_VARARGS, "\n"
		"ASTNode_renameSIdRefs(ASTNode self, string oldid, string newid)\n"
		"\n"
		"Renames all the SIdRef attributes on this node and any child node\n"
		"\n"
		""},
	 { "ASTNode_renameUnitSIdRefs", _wrap_ASTNode_renameUnitSIdRefs, METH_VARARGS, "\n"
		"ASTNode_renameUnitSIdRefs(ASTNode self, string oldid, string newid)\n"
		"\n"
		"Renames all the UnitSIdRef attributes on this node and any child node.\n"
		"\n"
		"The only place UnitSIDRefs appear is in MathML <cn> elements, so the\n"
		"effects of this method are limited to that.\n"
		"\n"
		"Parameter 'oldid' is the old identifier. Parameter 'newid' is the new\n"
		"identifier.\n"
		"\n"
		""},
	 { "ASTNode_replaceIDWithFunction", _wrap_ASTNode_replaceIDWithFunction, METH_VARARGS, "\n"
		"ASTNode_replaceIDWithFunction(ASTNode self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_multiplyTimeBy", _wrap_ASTNode_multiplyTimeBy, METH_VARARGS, "\n"
		"ASTNode_multiplyTimeBy(ASTNode self, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_unsetUnits", _wrap_ASTNode_unsetUnits, METH_O, "\n"
		"ASTNode_unsetUnits(ASTNode self) -> int\n"
		"\n"
		"Unsets the units of this ASTNode.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_UNEXPECTED_ATTRIBUTE\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "ASTNode_unsetId", _wrap_ASTNode_unsetId, METH_O, "\n"
		"ASTNode_unsetId(ASTNode self) -> int\n"
		"\n"
		"Unsets the MathML 'id' attribute of this ASTNode.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "ASTNode_unsetClass", _wrap_ASTNode_unsetClass, METH_O, "\n"
		"ASTNode_unsetClass(ASTNode self) -> int\n"
		"\n"
		"Unsets the MathML 'class' attribute of this ASTNode.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "ASTNode_unsetStyle", _wrap_ASTNode_unsetStyle, METH_O, "\n"
		"ASTNode_unsetStyle(ASTNode self) -> int\n"
		"\n"
		"Unsets the MathML 'style' attribute of this ASTNode.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "ASTNode_setDefinitionURL", _wrap_ASTNode_setDefinitionURL, METH_VARARGS, "\n"
		"ASTNode_setDefinitionURL(ASTNode self, XMLAttributes url) -> int\n"
		"ASTNode_setDefinitionURL(ASTNode self, string url) -> int\n"
		""},
	 { "ASTNode_getDefinitionURL", _wrap_ASTNode_getDefinitionURL, METH_O, "\n"
		"ASTNode_getDefinitionURL(ASTNode self) -> XMLAttributes\n"
		"\n"
		"Returns the MathML 'definitionURL' attribute value.\n"
		"\n"
		"Returns the value of the 'definitionURL' attribute, in the form of a\n"
		"libSBML XMLAttributes object.\n"
		"\n"
		"See also setDefinitionURL(), setDefinitionURL(),\n"
		"getDefinitionURLString().\n"
		"\n"
		""},
	 { "ASTNode_replaceArgument", _wrap_ASTNode_replaceArgument, METH_VARARGS, "\n"
		"ASTNode_replaceArgument(ASTNode self, string bvar, ASTNode arg)\n"
		"\n"
		"Replaces occurrences of a given name with a given ASTNode.\n"
		"\n"
		"For example, if the formula in this ASTNode is x + y, and the function\n"
		"is called with 'bvar' = ''x'' and 'arg' = an ASTNode representing the\n"
		"real value '3.'  This method would substitute '3' for 'x' within this\n"
		"ASTNode object, resulting in the forula 3 + y.\n"
		"\n"
		"Parameter 'bvar' is a string representing the variable name to be\n"
		"substituted. Parameter 'arg' is an ASTNode representing the\n"
		"name/value/formula to use as a replacement.\n"
		"\n"
		""},
	 { "ASTNode_getParentSBMLObject", _wrap_ASTNode_getParentSBMLObject, METH_O, "\n"
		"ASTNode_getParentSBMLObject(ASTNode self) -> SBase\n"
		"\n"
		"Returns the parent SBML object.\n"
		"\n"
		"Returns the parent SBML object of this ASTNode.\n"
		"\n"
		"See also isSetParentSBMLObject(), unsetParentSBMLObject().\n"
		"\n"
		""},
	 { "ASTNode_unsetParentSBMLObject", _wrap_ASTNode_unsetParentSBMLObject, METH_O, "\n"
		"ASTNode_unsetParentSBMLObject(ASTNode self) -> int\n"
		"\n"
		"Unsets the parent SBML object.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		"See also isSetParentSBMLObject(), getParentSBMLObject().\n"
		"\n"
		""},
	 { "ASTNode_isSetParentSBMLObject", _wrap_ASTNode_isSetParentSBMLObject, METH_O, "\n"
		"ASTNode_isSetParentSBMLObject(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' if this node has a value for the parent SBML object.\n"
		"\n"
		"Returns 'True' if this ASTNode has an parent SBML object set, 'False'\n"
		"otherwise.\n"
		"\n"
		"See also getParentSBMLObject(), unsetParentSBMLObject().\n"
		"\n"
		""},
	 { "ASTNode_reduceToBinary", _wrap_ASTNode_reduceToBinary, METH_O, "\n"
		"ASTNode_reduceToBinary(ASTNode self)\n"
		"\n"
		"Reduces this ASTNode to a binary tree.\n"
		"\n"
		"Example: if this ASTNode is and(x, y, z), then the formula of the\n"
		"reduced node is and(and(x, y), z).  The operation replaces the formula\n"
		"stored in the current ASTNode object.\n"
		"\n"
		""},
	 { "ASTNode_unsetUserData", _wrap_ASTNode_unsetUserData, METH_O, "\n"
		"ASTNode_unsetUserData(ASTNode self) -> int\n"
		"\n"
		"Unsets the user data of this node.\n"
		"\n"
		"The user data can be used by the application developer to attach\n"
		"custom information to the node.  In case of a deep copy, this\n"
		"attribute will passed as it is. The attribute will be never\n"
		"interpreted by this class.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_OPERATION_FAILED\n"
		"\n"
		""},
	 { "ASTNode_isSetUserData", _wrap_ASTNode_isSetUserData, METH_O, "\n"
		"ASTNode_isSetUserData(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' if this node has a user data object.\n"
		"\n"
		"Returns 'True' if this ASTNode has a user data object set, 'False'\n"
		"otherwise.\n"
		"\n"
		""},
	 { "ASTNode_isWellFormedASTNode", _wrap_ASTNode_isWellFormedASTNode, METH_O, "\n"
		"ASTNode_isWellFormedASTNode(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' or 'False' depending on whether this ASTNode is well-\n"
		"formed.\n"
		"\n"
		"Note: An ASTNode may be well-formed, with each node and its children\n"
		"having the appropriate number of children for the given type, but may\n"
		"still be invalid in the context of its use within an SBML model.\n"
		"\n"
		"Returns 'True' if this ASTNode is well-formed, 'False' otherwise.\n"
		"\n"
		"See also hasCorrectNumberArguments().\n"
		"\n"
		""},
	 { "ASTNode_hasCorrectNumberArguments", _wrap_ASTNode_hasCorrectNumberArguments, METH_O, "\n"
		"ASTNode_hasCorrectNumberArguments(ASTNode self) -> bool\n"
		"\n"
		"Returns 'True' if this ASTNode has the correct number of children for\n"
		"its type.\n"
		"\n"
		"For example, an ASTNode with type AST_MINUS expects 1 or 2 child\n"
		"nodes.\n"
		"\n"
		"Returns 'True' if this ASTNode has the appropriate number of children\n"
		"for its type, 'False' otherwise.\n"
		"\n"
		"Note: This function performs a check on the top-level node only.\n"
		"Child nodes are not checked.\n"
		"\n"
		"See also isWellFormedASTNode().\n"
		"\n"
		""},
	 { "ASTNode_getDefinitionURLString", _wrap_ASTNode_getDefinitionURLString, METH_O, "\n"
		"ASTNode_getDefinitionURLString(ASTNode self) -> string\n"
		"\n"
		"Returns the MathML 'definitionURL' attribute value as a string.\n"
		"\n"
		"Returns the value of the 'definitionURL' attribute, as a string.\n"
		"\n"
		"See also getDefinitionURL(), setDefinitionURL(), setDefinitionURL().\n"
		"\n"
		""},
	 { "ASTNode_representsBvar", _wrap_ASTNode_representsBvar, METH_O, "\n"
		"ASTNode_representsBvar(ASTNode self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_isBvar", _wrap_ASTNode_isBvar, METH_O, "\n"
		"ASTNode_isBvar(ASTNode self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_setBvar", _wrap_ASTNode_setBvar, METH_O, "\n"
		"ASTNode_setBvar(ASTNode self)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_usesL3V2MathConstructs", _wrap_ASTNode_usesL3V2MathConstructs, METH_O, "\n"
		"ASTNode_usesL3V2MathConstructs(ASTNode self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_usesRateOf", _wrap_ASTNode_usesRateOf, METH_O, "\n"
		"ASTNode_usesRateOf(ASTNode self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_isQualifier", _wrap_ASTNode_isQualifier, METH_O, "\n"
		"ASTNode_isQualifier(ASTNode self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_isSemantics", _wrap_ASTNode_isSemantics, METH_O, "\n"
		"ASTNode_isSemantics(ASTNode self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_getNumBvars", _wrap_ASTNode_getNumBvars, METH_O, "\n"
		"ASTNode_getNumBvars(ASTNode self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_addPlugin", _wrap_ASTNode_addPlugin, METH_VARARGS, "\n"
		"ASTNode_addPlugin(ASTNode self, ASTBasePlugin plugin)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_loadASTPlugins", _wrap_ASTNode_loadASTPlugins, METH_VARARGS, "\n"
		"ASTNode_loadASTPlugins(ASTNode self, SBMLNamespaces sbmlns)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_loadASTPlugin", _wrap_ASTNode_loadASTPlugin, METH_VARARGS, "\n"
		"ASTNode_loadASTPlugin(ASTNode self, string pkgName)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_getASTPlugin", _wrap_ASTNode_getASTPlugin, METH_VARARGS, "\n"
		"ASTNode_getASTPlugin(ASTNode self, SBMLNamespaces sbmlns) -> ASTBasePlugin\n"
		"ASTNode_getASTPlugin(ASTNode self, ASTNodeType_t type) -> ASTBasePlugin\n"
		"ASTNode_getASTPlugin(ASTNode self, string name, bool isCsymbol=False, bool strCmpIsCaseSensitive=False) -> ASTBasePlugin\n"
		"ASTNode_getASTPlugin(ASTNode self, SBMLNamespaces sbmlns) -> ASTBasePlugin\n"
		"ASTNode_getASTPlugin(ASTNode self, ASTNodeType_t type) -> ASTBasePlugin\n"
		"ASTNode_getASTPlugin(ASTNode self, string name, bool isCsymbol=False, bool strCmpIsCaseSensitive=False) -> ASTBasePlugin\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getASTPlugin(SBMLNamespaces  sbmlns)\n"
		"\n"
		"Returns a plug-in object (extension interface) for an SBML Level 3\n"
		"package extension with the given 'sbmlns'.\n"
		"\n"
		"Parameter 'sbmlns' is the namespace of the plugin to return.\n"
		"\n"
		"Returns the plug-in object (the libSBML extension interface) of a\n"
		"package extension with the given package name or URI, or 'None' if\n"
		"none exist.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getASTPlugin(string name, bool isCsymbol = false, bool\n"
		"strCmpIsCaseSensitive = false)\n"
		"\n"
		"Returns a plug-in object (extension interface) for an SBML Level 3\n"
		"package extension for the package with the given constraints.\n"
		"\n"
		"Parameter 'name' is the type or csymbol defined by the returned\n"
		"plugin. Parameter 'isCsymbol' is Boolean indicator of whether the\n"
		"'name' is a csymbol (if 'True)' or type (if 'False).' Parameter\n"
		"'strCmpIsCaseSensitive' is whether to search for the matching type or\n"
		"csymbol in case-sensitve manner (if 'True)' or case-insensitive manner\n"
		"(if 'False).'\n"
		"\n"
		"Returns the plug-in object (the libSBML extension interface) of a\n"
		"package extension that defines the given 'name', or 'None' if none\n"
		"exist.\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    getASTPlugin(ASTNodeType_t type)\n"
		"\n"
		"Returns a plug-in object (extension interface) for an SBML Level 3\n"
		"package extension for the package that defines the given 'type'.\n"
		"\n"
		"Parameter 'type' is the type that is defined by the given plugin.\n"
		"\n"
		"Returns the plug-in object (the libSBML extension interface) of a\n"
		"package extension that defines the given 'type', or 'None' if none\n"
		"exist.\n"
		"\n"
		""},
	 { "ASTNode_getPlugin", _wrap_ASTNode_getPlugin, METH_VARARGS, "\n"
		"ASTNode_getPlugin(ASTNode self, string package) -> ASTBasePlugin\n"
		"ASTNode_getPlugin(ASTNode self, string package) -> ASTBasePlugin\n"
		"ASTNode_getPlugin(ASTNode self, unsigned int n) -> ASTBasePlugin\n"
		"ASTNode_getPlugin(ASTNode self, unsigned int n) -> ASTBasePlugin\n"
		""},
	 { "ASTNode_getNumPlugins", _wrap_ASTNode_getNumPlugins, METH_O, "\n"
		"ASTNode_getNumPlugins(ASTNode self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTNode_getListOfNodes", _wrap_ASTNode_getListOfNodes, METH_O, "\n"
		"ASTNode_getListOfNodes(ASTNode self) -> ASTNodeList\n"
		"\n"
		"Returns a list of nodes.\n"
		"\n"
		"Unlike the equivalent method in the libSBML C/C++ interface, this method does\n"
		"not offer the ability to pass a predicate as an argument.  The method always\n"
		"returns the list of all ASTNode objects.\n"
		"\n"
		"@return the ASTNodeList of nodes.\n"
		"\n"
		"@warning The list returned is owned by the caller and should be deleted after\n"
		"the caller is done using it.  The ASTNode objects in the list; however, are\n"
		"<strong>not</strong> owned by the caller (as they still belong to the tree\n"
		"itself), and therefore should not be deleted.\n"
		"\n"
		""},
	 { "ASTNode_swigregister", ASTNode_swigregister, METH_O, NULL},
	 { "ASTNode_swiginit", ASTNode_swiginit, METH_VARARGS, NULL},
	 { "readMathMLFromString", _wrap_readMathMLFromString, METH_O, "\n"
		"readMathMLFromString(char const * xml) -> ASTNode\n"
		"\n"
		"Reads the MathML from the given XML string, constructs a corresponding\n"
		"abstract syntax tree, and returns a pointer to the root of the tree.\n"
		"\n"
		"Parameter 'xml' is a string containing a full MathML expression.\n"
		"\n"
		"Returns the root of an AST corresponding to the given mathematical\n"
		"expression, otherwise 'None' is returned if the given string is 'None'\n"
		"or invalid.\n"
		"\n"
		""},
	 { "readMathMLFromStringWithNamespaces", _wrap_readMathMLFromStringWithNamespaces, METH_VARARGS, "\n"
		"readMathMLFromStringWithNamespaces(char const * xml, XMLNamespaces xmlns) -> ASTNode\n"
		"\n"
		"Reads the MathML from the given XML string, constructs a corresponding\n"
		"abstract syntax tree, and returns a pointer to the root of the tree.\n"
		"\n"
		"Parameter 'xml' is a string containing a full MathML expression.\n"
		"Parameter 'xmlns' is an XMLNamespaces object containing namespaces\n"
		"that are considered active during the read. (For example, an SBML\n"
		"Level 3 package namespace.)\n"
		"\n"
		"Returns the root of an AST corresponding to the given mathematical\n"
		"expression, otherwise 'None' is returned if the given string is 'None'\n"
		"or invalid.\n"
		"\n"
		""},
	 { "writeMathMLToString", _wrap_writeMathMLToString, METH_O, "\n"
		"writeMathMLToString(ASTNode node) -> char *\n"
		"\n"
		"Writes the given AST node (and its children) to a string as MathML,\n"
		"and returns the string.\n"
		"\n"
		"Parameter 'node' is the root of an AST to write out to the stream.\n"
		"\n"
		"Returns a string containing the written-out MathML representation of\n"
		"the given AST.\n"
		"\n"
		"Note: The string is owned by the caller and should be freed (with\n"
		"free()) when no longer needed.  'None' is returned if the given\n"
		"argument is 'None.'\n"
		"\n"
		""},
	 { "writeMathMLWithNamespaceToString", _wrap_writeMathMLWithNamespaceToString, METH_VARARGS, "\n"
		"writeMathMLWithNamespaceToString(ASTNode node, SBMLNamespaces sbmlns) -> char *\n"
		"\n"
		"Writes the given AST node (and its children) to a string as MathML,\n"
		"and returns the string.\n"
		"\n"
		"Parameter 'node' is the root of an AST to write out to the stream.\n"
		"Parameter 'sbmlns' is the SBML namespace to be used\n"
		"\n"
		"Returns a string containing the written-out MathML representation of\n"
		"the given AST.\n"
		"\n"
		"Note: The string is owned by the caller and should be freed (with\n"
		"free()) when no longer needed.  'None' is returned if the given\n"
		"argument is 'None.'\n"
		"\n"
		""},
	 { "parseFormula", _wrap_parseFormula, METH_O, "\n"
		"parseFormula(char const * formula) -> ASTNode\n"
		"\n"
		"Parses a text string as a mathematical formula and returns an AST\n"
		"representation of it.\n"
		"\n"
		"The text-string form of mathematical formulas produced by\n"
		"formulaToString() and read by parseFormula() use a simple C-inspired\n"
		"infix notation taken from SBML Level 1.  A formula in this text-string\n"
		"form therefore can be handed to a program that understands SBML Level\n"
		"1 mathematical expressions, or used as part of a formula translation\n"
		"system. The syntax is described in detail in the documentation for\n"
		"ASTNode.  The following are illustrative examples of formulas\n"
		"expressed using this syntax:\n"
		"\n"
		"  0.10 * k4^2\n"
		"\n"
		"  (vm * s1)/(km + s1)\n"
		"\n"
		"Note that this facility is provided as a convenience by libSBML---the\n"
		"MathML standard does not actually define a 'string-form' equivalent to\n"
		"MathML expression trees, so the choice of formula syntax is somewhat\n"
		"arbitrary.  The approach taken by libSBML is to use the syntax defined\n"
		"by SBML Level 1 (which in fact used a text-string representation of\n"
		"formulas and not MathML).  This formula syntax is based mostly on C\n"
		"programming syntax, and may contain operators, function calls,\n"
		"symbols, and white space characters.  The following table provides the\n"
		"precedence rules for the different entities that may appear in formula\n"
		"strings.\n"
		"\n"
		"  +--------------+---------------------+---------+------------+------------+\n"
		"  | Token        | Operation           | Class   | Precedence | Associates |\n"
		"  +--------------+---------------------+---------+------------+------------+\n"
		"  | name         | symbol reference    | operand | 6          | n/a        |\n"
		"  | (expression) | expression grouping | operand | 6          | n/a        |\n"
		"  | f(...)       | function call       | prefix  | 6          | left       |\n"
		"  | -            | negation            | unary   | 5          | right      |\n"
		"  | ^            | power               | binary  | 4          | left       |\n"
		"  | *            | multiplication      | binary  | 3          | left       |\n"
		"  | /            | divison             | binary  | 3          | left       |\n"
		"  | +            | addition            | binary  | 2          | left       |\n"
		"  | -            | subtraction         | binary  | 2          | left       |\n"
		"  | ,            | argument delimiter  | binary  | 1          | left       |\n"
		"  +--------------+---------------------+---------+------------+------------+\n"
		"\n"
		"In the table above, operand implies the construct is an operand,\n"
		"prefix implies the operation is applied to the following arguments,\n"
		"unary implies there is one argument, and binary implies there are two\n"
		"arguments.  The values in the Precedence column show how the order of\n"
		"different types of operation are determined.  For example, the\n"
		"expression a * b + c is evaluated as (a * b) + c because the '*'\n"
		"operator has higher precedence.  The Associates column shows how the\n"
		"order of similar precedence operations is determined; for example, a -\n"
		"b + c is evaluated as (a - b) + c because the '+' and '-' operators\n"
		"are left-associative.\n"
		"\n"
		"The function call syntax consists of a function name, followed by\n"
		"optional white space, followed by an opening parenthesis token,\n"
		"followed by a sequence of zero or more arguments separated by commas\n"
		"(with each comma optionally preceded and/or followed by zero or more\n"
		"white space characters, followed by a closing parenthesis token.  The\n"
		"function name must be chosen from one of the pre-defined functions in\n"
		"SBML or a user-defined function in the model.  The following table\n"
		"lists the names of certain common mathematical functions; this table\n"
		"corresponds to Table 6 in the SBML Level 1 Version 2 specification:\n"
		"\n"
		"  +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+\n"
		"  | Name  | Args | Formula or meaning                                                | Argument Constraints           | Result constraints |\n"
		"  +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+\n"
		"  | abs   | x    | absolute value of x                                               |                                |                    |\n"
		"  | acos  | x    | arc cosine of x in radians                                        | -1.0 <= x <= 1.0               | 0 <= acos(x) <= Pi |\n"
		"  | asin  | x    | arc sine of x in radians                                          | -1.0 <= x <= 1.0               | 0 <= asin(x) <= Pi |\n"
		"  | atan  | x    | arc tangent of x in radians                                       |                                | 0 <= atan(x) <= Pi |\n"
		"  | ceil  | x    | smallest number not less than x whose value is an exact integer   |                                |                    |\n"
		"  | cos   | x    | cosine of x                                                       |                                |                    |\n"
		"  | exp   | x    | e^x, where e is the base of the natural logarithm                 |                                |                    |\n"
		"  | floor | x    | largest number not greater than x whose value is an exact integer |                                |                    |\n"
		"  | log   | x    | natural logarithm of x                                            | x > 0                          |                    |\n"
		"  | log10 | x    | base 10 logarithm of x                                            | x > 0                          |                    |\n"
		"  | pow   | x, y | x^y                                                               |                                |                    |\n"
		"  | sqr   | x    | x^2                                                               |                                |                    |\n"
		"  | sqrt  | x    | &radic;x                                                          | x > 0                          | sqrt(x) >= 0       |\n"
		"  | sin   | x    | sine of x                                                         |                                |                    |\n"
		"  | tan   | x    | tangent of x                                                      | x != n*Pi/2, for odd integer n |                    |\n"
		"  +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+\n"
		"\n"
		"WARNING:\n"
		"\n"
		"There are differences between the symbols used to represent the common\n"
		"mathematical functions and the corresponding MathML token names.  This\n"
		"is a potential source of incompatibilities. Note in particular that in\n"
		"this text-string syntax, log(x) represents the natural logarithm,\n"
		"whereas in MathML, the natural logarithm is <ln/>.  Application\n"
		"writers are urged to be careful when translating between text forms\n"
		"and MathML forms, especially if they provide a direct text-string\n"
		"input facility to users of their software systems.\n"
		"\n"
		"Parameter 'formula' is the text-string formula expression to be\n"
		"parsed.\n"
		"\n"
		"Returns the root node of the AST corresponding to the 'formula', or\n"
		"'None' if an error occurred in parsing the formula\n"
		"\n"
		"See also parseL3Formula(), formulaToString(), formulaToL3String(),\n"
		"formulaToL3StringWithSettings(), parseL3FormulaWithSettings(),\n"
		"parseL3FormulaWithModel(), L3ParserSettings.\n"
		"\n"
		"Note: Callers using SBML Level 3 are encouraged to use the facilities\n"
		"provided by libSBML's newer and more powerful Level 3-oriented formula\n"
		"parser and formatter.  The entry points to this second system are\n"
		"parseL3Formula() and formulaToL3String().  The Level 1-oriented system\n"
		"(i.e., what is provided by formulaToString() and parseFormula()) is\n"
		"provided untouched for backwards compatibility.\n"
		"\n"
		"Note: We urge developers to keep in mind that the text-string formula\n"
		"syntax is specific to libSBML.  Neither MathML nor SBML define a text-\n"
		"string format for mathematical formulas. LibSBML's particular syntax\n"
		"should not be considered to be a canonical or standard general-purpose\n"
		"mathematical expression syntax.  LibSBML provides methods for parsing\n"
		"and transforming text-string math formulas back and forth from AST\n"
		"structures for the convenience of calling applications, but it is\n"
		"important to keep the system's limitations in mind.\n"
		"\n"
		""},
	 { "formulaToL3String", _wrap_formulaToL3String, METH_O, "\n"
		"formulaToL3String(ASTNode tree) -> char *\n"
		"\n"
		"Converts an AST to a string representation of a formula using a syntax\n"
		"derived from SBML Level 1, but extended to include elements from SBML\n"
		"Level 2 and SBML Level 3.\n"
		"\n"
		"The text-string form of mathematical formulas read by the function\n"
		"parseL3Formula() and written by the function formulaToL3String() uses\n"
		"an expanded version of the syntax read and written by parseFormula()\n"
		"and formulaToString(), respectively.  The latter two libSBML functions\n"
		"were originally developed to support conversion between SBML Levels 1\n"
		"and 2, and were focused on the syntax of mathematical formulas used in\n"
		"SBML Level 1.  With time, and the use of MathML in SBML Levels 2 and\n"
		"3, it became clear that supporting Level 2 and 3's expanded\n"
		"mathematical syntax would be useful for software developers.  To\n"
		"maintain backwards compatibility for libSBML users, the original\n"
		"formulaToString() and parseFormula() have been left untouched, and\n"
		"instead, the new functionality is provided in the form of\n"
		"parseL3Formula() and formulaToL3String().\n"
		"\n"
		"The following lists the main differences in the formula syntax\n"
		"supported by the Level 3 ('L3') versions of the formula parsers and\n"
		"formatters, compared to what is supported by the Level 1-oriented\n"
		"parseFormula() and formulaToString():\n"
		"\n"
		"* Units may be asociated with bare numbers, using the following\n"
		"syntax:\n"
		"\n"
		"number unit\n"
		"\n"
		"The number may be in any form (an integer, real, or rational number),\n"
		"and the unit must conform to the syntax of an SBML identifier\n"
		"(technically, the type defined as 'SId' in the SBML specifications).\n"
		"The whitespace between number and unit is optional.\n"
		"\n"
		"* The Boolean function symbols '&&' (and), '||' (or), '!' (not),\n"
		"and '!=' (not equals) may be used.\n"
		"\n"
		"* The modulo operation is allowed as the symbol '%' and will\n"
		"produce a <piecewise> function in the corresponding MathML output by\n"
		"default, or can produce the MathML function 'rem,'  depending on the\n"
		"L3ParserSettings object (see  L3ParserSettings_setParseModuloL3v2() ).\n"
		"\n"
		"* All inverse trigonometric functions may be defined in the infix\n"
		"either using 'arc' as a prefix or simply 'a;' in other words, both\n"
		"'arccsc' and 'acsc' are interpreted as the operator arccosecant as\n"
		"defined in MathML 2.0.  (Many functions in the simpler SBML Level 1\n"
		"oriented parser implemented by parseFormula() are defined this way as\n"
		"well, but not all.)\n"
		"\n"
		"* The following expression is parsed as a rational number instead\n"
		"of as a numerical division:\n"
		"\n"
		"  (integer/integer)\n"
		"\n"
		"Spaces are not allowed in this construct; in other words, \"(3 / 4)\"\n"
		"(with whitespace between the numbers and the operator) will be parsed\n"
		"into the MathML <divide> construct rather than a rational number.  You\n"
		"can, however, assign units to a rational number as a whole; here is an\n"
		"example: \"(3/4) ml\". (In the case of division rather than a rational\n"
		"number, units are not interpreted in this way.)\n"
		"\n"
		"* Various parser and formatter behaviors may be altered through\n"
		"the use of a L3ParserSettings object in conjunction with the functions\n"
		"parseL3FormulaWithSettings() and formulaToL3StringWithSettings() The\n"
		"settings available include the following:\n"
		"\n"
		"* The function 'log' with a single argument (\"log(x)\") can be parsed\n"
		"as log10(x), ln(x), or treated as an error, as desired.\n"
		"\n"
		"* Unary minus signs can be collapsed or preserved; that is, sequential\n"
		"pairs of unary minuses (e.g., \"- -3\") can be removed from the input\n"
		"entirely and single unary minuses can be incorporated into the number\n"
		"node, or all minuses can be preserved in the AST node structure.\n"
		"\n"
		"* Parsing of units embedded in the input string can be turned on and\n"
		"off.\n"
		"\n"
		"* The string 'avogadro' can be parsed as a MathML csymbol or as an\n"
		"identifier.\n"
		"\n"
		"* The string % can be parsed either as a  piecewise function or as the\n"
		"'rem' function:  a % b will either become\n"
		"\n"
		"piecewise(a - b*ceil(a/b), xor((a < 0), (b < 0)), a - b*floor(a/b))\n"
		"\n"
		"or\n"
		"\n"
		"rem(a, b).\n"
		"\n"
		"The latter is simpler, but the 'rem' MathML is only allowed as of SBML\n"
		"Level 3 Version 2.* A Model object may optionally be provided to the\n"
		"parser using the variant function call parseL3FormulaWithModel() or\n"
		"stored in a L3ParserSettings object passed to the variant function\n"
		"parseL3FormulaWithSettings().  When a Model object is provided,\n"
		"identifiers (values of type 'SId' ) from that model are used in\n"
		"preference to pre-defined MathML definitions for both symbols and\n"
		"functions. More precisely:\n"
		"\n"
		"* In the case of symbols: the Model entities whose identifiers will\n"
		"shadow identical symbols in the mathematical formula are: Species,\n"
		"Compartment, Parameter, Reaction, and SpeciesReference.  For instance,\n"
		"if the parser is given a Model containing a Species with the\n"
		"identifier \"pi\", and the formula to be parsed is \"3*pi\", the\n"
		"MathML produced will contain the construct <ci> pi </ci> instead of\n"
		"the construct <pi/>.\n"
		"\n"
		"* In the case of user-defined functions: when a Model object is\n"
		"provided, 'SId' values of user-defined functions present in the model\n"
		"will be used preferentially over pre-defined MathML functions.  For\n"
		"example, if the passed-in Model contains a FunctionDefinition object\n"
		"with the identifier \"sin\", that function will be used instead of the\n"
		"predefined MathML function <sin/>.\n"
		"\n"
		"* An SBMLNamespaces object may optionally be provided to identify\n"
		"SBML Level 3 packages that extend the syntax understood by the formula\n"
		"parser.  When the namespaces are provided, the parser will interpret\n"
		"possible additional syntax defined by the libSBML plug-ins\n"
		"implementing the SBML Level 3 packages; for example, it may understand\n"
		"vector/array extensions introduced by the SBML Level 3 Arrays package.\n"
		"These configuration settings cannot be changed directly using the\n"
		"basic parser and formatter functions, but can be changed on a per-call\n"
		"basis by using the alternative functions parseL3FormulaWithSettings()\n"
		"and formulaToL3StringWithSettings().\n"
		"\n"
		"Neither SBML nor the MathML standard define a 'string-form' equivalent\n"
		"to MathML expressions.  The approach taken by libSBML is to start with\n"
		"the formula syntax defined by SBML Level 1 (which in fact used a\n"
		"custom text-string representation of formulas, and not MathML), and\n"
		"expand it to include the functionality described above.  This formula\n"
		"syntax is based mostly on C programming syntax, and may contain\n"
		"operators, function calls, symbols, and white space characters.  The\n"
		"following table provides the precedence rules for the different\n"
		"entities that may appear in formula strings.\n"
		"\n"
		"  +----------------------+--------------------------+---------+---------+--------+\n"
		"  | Token                | Operation                | Class   | Preced. | Assoc. |\n"
		"  +----------------------+--------------------------+---------+---------+--------+\n"
		"  | name                 | symbol reference         | operand | 8       | n/a    |\n"
		"  | (expression)         | expression grouping      | operand | 8       | n/a    |\n"
		"  | f(...)               | function call            | prefix  | 8       | left   |\n"
		"  | ^                    | power                    | binary  | 7       | left   |\n"
		"  | -, !                 | negation, Boolean 'not'  | unary   | 6       | right  |\n"
		"  | *, /, %              | multip., div., modulo    | binary  | 5       | left   |\n"
		"  | +, -                 | addition and subtraction | binary  | 4       | left   |\n"
		"  | ==, <, >, <=, >=, != | Boolean comparisons      | binary  | 3       | left   |\n"
		"  | &&, ||               | Boolean 'and' and 'or'   | binary  | 2       | left   |\n"
		"  | ,                    | argument delimiter       | binary  | 1       | left   |\n"
		"  +----------------------+--------------------------+---------+---------+--------+\n"
		"\n"
		"In the table above, operand implies the construct is an operand,\n"
		"prefix implies the operation is applied to the following arguments,\n"
		"unary implies there is one argument, and binary implies there are two\n"
		"arguments.  The values in the Precedence column show how the order of\n"
		"different types of operation are determined.  For example, the\n"
		"expression a + b * c is evaluated as a + (b * c) because the '*'\n"
		"operator has higher precedence.  The Associates column shows how the\n"
		"order of similar precedence operations is determined; for example, a\n"
		"&& b || c is evaluated as (a && b) || c because the '&&' and '||'\n"
		"operators are left-associative and have the same precedence.\n"
		"\n"
		"The function call syntax consists of a function name, followed by\n"
		"optional white space, followed by an opening parenthesis token,\n"
		"followed by a sequence of zero or more arguments separated by commas\n"
		"(with each comma optionally preceded and/or followed by zero or more\n"
		"white space characters), followed by a closing parenthesis token.  The\n"
		"function name must be chosen from one of the pre-defined functions in\n"
		"SBML or a user-defined function in the model.  The following table\n"
		"lists the names of certain common mathematical functions; this table\n"
		"corresponds to Table 6 in the SBML Level 1 Version 2 specification\n"
		"with additions based on the functions added in SBML Level 2 and Level\n"
		"3:\n"
		"\n"
		"  +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+\n"
		"  | Name           | Argument(s)                 | Formula or meaning                                                                                                                                                                    | Argument Constraints             | Result constraints |\n"
		"  +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+\n"
		"  | abs            | x                           | Absolute value of x.                                                                                                                                                                  |                                  |                    |\n"
		"  | acos, arccos   | x                           | Arccosine of x in radians.                                                                                                                                                            | -1.0 <= x <= 1.0                 | 0 <= acos(x) <= Pi |\n"
		"  | acosh, arccosh | x                           | Hyperbolic arccosine of x in radians.                                                                                                                                                 |                                  |                    |\n"
		"  | acot, arccot   | x                           | Arccotangent of x in radians.                                                                                                                                                         |                                  |                    |\n"
		"  | acoth, arccoth | x                           | Hyperbolic arccotangent of x in radians.                                                                                                                                              |                                  |                    |\n"
		"  | acsc, arccsc   | x                           | Arccosecant of x in radians.                                                                                                                                                          |                                  |                    |\n"
		"  | acsch, arccsch | x                           | Hyperbolic arccosecant of x in radians.                                                                                                                                               |                                  |                    |\n"
		"  | asec, arcsec   | x                           | Arcsecant of x in radians.                                                                                                                                                            |                                  |                    |\n"
		"  | asech, arcsech | x                           | Hyperbolic arcsecant of x in radians.                                                                                                                                                 |                                  |                    |\n"
		"  | asin, arcsin   | x                           | Arcsine of x in radians.                                                                                                                                                              | -1.0 <= x <= 1.0                 | 0 <= asin(x) <= Pi |\n"
		"  | atan, arctan   | x                           | Arctangent of x in radians.                                                                                                                                                           |                                  | 0 <= atan(x) <= Pi |\n"
		"  | atanh, arctanh | x                           | Hyperbolic arctangent of x in radians.                                                                                                                                                |                                  |                    |\n"
		"  | ceil, ceiling  | x                           | Smallest number not less than x whose value is an exact integer.                                                                                                                      |                                  |                    |\n"
		"  | cos            | x                           | Cosine of x                                                                                                                                                                           |                                  |                    |\n"
		"  | cosh           | x                           | Hyperbolic cosine of x.                                                                                                                                                               |                                  |                    |\n"
		"  | cot            | x                           | Cotangent of x.                                                                                                                                                                       |                                  |                    |\n"
		"  | coth           | x                           | Hyperbolic cotangent of x.                                                                                                                                                            |                                  |                    |\n"
		"  | csc            | x                           | Cosecant of x.                                                                                                                                                                        |                                  |                    |\n"
		"  | csch           | x                           | Hyperbolic cosecant of x.                                                                                                                                                             |                                  |                    |\n"
		"  | delay          | x, y                        | The value of x at y time units in the past.                                                                                                                                           |                                  |                    |\n"
		"  | factorial      | n                           | The factorial of n. Factorials are defined by n! = n*(n-1)* ... * 1.                                                                                                                  | n must be an integer.            |                    |\n"
		"  | exp            | x                           | e^x, where e is the base of the natural logarithm.                                                                                                                                    |                                  |                    |\n"
		"  | floor          | x                           | The largest number not greater than x whose value is an exact integer.                                                                                                                |                                  |                    |\n"
		"  | ln             | x                           | Natural logarithm of x.                                                                                                                                                               | x > 0                            |                    |\n"
		"  | 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                            |                    |\n"
		"  | log            | x, y                        | The base x logarithm of y.                                                                                                                                                            | y > 0                            |                    |\n"
		"  | log10          | x                           | Base 10 logarithm of x.                                                                                                                                                               | x > 0                            |                    |\n"
		"  | 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 |                    |\n"
		"  | pow, power     | x, y                        | x^y.                                                                                                                                                                                  |                                  |                    |\n"
		"  | root           | b, x                        | The root base b of x.                                                                                                                                                                 |                                  |                    |\n"
		"  | sec            | x                           | Secant of x.                                                                                                                                                                          |                                  |                    |\n"
		"  | sech           | x                           | Hyperbolic secant of x.                                                                                                                                                               |                                  |                    |\n"
		"  | sqr            | x                           | x^2.                                                                                                                                                                                  |                                  |                    |\n"
		"  | sqrt           | x                           | &radic;x.                                                                                                                                                                             | x > 0                            | sqrt(x) >= 0       |\n"
		"  | sin            | x                           | Sine of x.                                                                                                                                                                            |                                  |                    |\n"
		"  | sinh           | x                           | Hyperbolic sine of x.                                                                                                                                                                 |                                  |                    |\n"
		"  | tan            | x                           | Tangent of x.                                                                                                                                                                         | x != n*Pi/2, for odd integer n   |                    |\n"
		"  | tanh           | x                           | Hyperbolic tangent of x.                                                                                                                                                              |                                  |                    |\n"
		"  | 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    |                    |\n"
		"  | not            | x                           | Boolean not(x)                                                                                                                                                                        | x must be Boolean                |                    |\n"
		"  | 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    |                    |\n"
		"  | 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    |                    |\n"
		"  | 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.                                               |                                  |                    |\n"
		"  | 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. |                                  |                    |\n"
		"  | 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.               |                                  |                    |\n"
		"  | 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.    |                                  |                    |\n"
		"  | 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.                  |                                  |                    |\n"
		"  | neq            | x, y                        | Boolean x != y: returns true unless x and y are equal.                                                                                                                                |                                  |                    |\n"
		"  | 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.                                |                                  |                    |\n"
		"  | 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.                          |                                  |                    |\n"
		"  | minus          | x, y                        | x - y.                                                                                                                                                                                |                                  |                    |\n"
		"  | divide         | x, y                        | x / y.                                                                                                                                                                                |                                  |                    |\n"
		"  +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+\n"
		"\n"
		"Parsing of the various MathML functions and constants are all case-\n"
		"insensitive by default: function names such as cos, Cos and COS are\n"
		"all parsed as the MathML cosine operator, <cos>.  However, when a\n"
		"Model object is used in conjunction with either\n"
		"parseL3FormulaWithModel() or parseL3FormulaWithSettings(), any\n"
		"identifiers found in that model will be parsed in a case-sensitive\n"
		"way.  For example, if a model contains a Species having the identifier\n"
		"Pi, the parser will parse \"Pi\" in the input as \"<ci> Pi </ci>\" but\n"
		"will continue to parse the symbols \"pi\" and \"PI\" as \"<pi>\".\n"
		"\n"
		"As mentioned above, the manner in which the 'L3' versions of the\n"
		"formula parser and formatter interpret the function \"log\" can be\n"
		"changed.  To do so, callers should use the function\n"
		"parseL3FormulaWithSettings() and pass it an appropriate\n"
		"L3ParserSettings object.  By default, unlike the SBML Level 1 parser\n"
		"implemented by parseFormula(), the string \"log\" is interpreted as\n"
		"the base 10 logarithm, and not as the natural logarithm.  However, you\n"
		"can change the interpretation to be base-10 log, natural log, or as an\n"
		"error; since the name 'log' by itself is ambiguous, you require that\n"
		"the parser uses 'log10' or 'ln' instead, which are more clear.  Please\n"
		"refer to parseL3FormulaWithSettings().\n"
		"\n"
		"In addition, the following symbols will be translated to their MathML\n"
		"equivalents, if no symbol with the same 'SId' identifier string exists\n"
		"in the Model object provided:\n"
		"\n"
		"  +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+\n"
		"  | Name            | Meaning                                         | MathML                                                                                                       |\n"
		"  +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+\n"
		"  | true            | Boolean value true                              | <true/>                                                                                                      |\n"
		"  | false           | Boolean value false                             | <false/>                                                                                                     |\n"
		"  | pi              | Mathematical constant pi                        | <pi/>                                                                                                        |\n"
		"  | avogadro        | Value of Avogadro's constant stipulated by SBML | <csymbol encoding=\"text\" definitionURL=\"http://www.sbml.org/sbml/symbols/avogadro\"> avogadro </csymbol/> |\n"
		"  | time            | Simulation time as defined in SBML              | <csymbol encoding=\"text\" definitionURL=\"http://www.sbml.org/sbml/symbols/time\"> time </csymbol/>         |\n"
		"  | inf, infinity   | Mathematical constant \"infinity\"              | <infinity/>                                                                                                  |\n"
		"  | nan, notanumber | Mathematical concept \"not a number\"           | <notanumber/>                                                                                                |\n"
		"  +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+\n"
		"\n"
		"Again, as mentioned above, whether the string \"avogadro\" is parsed\n"
		"as an AST node of type AST_NAME_AVOGADRO or AST_NAME is configurable;\n"
		"use the version of the parser function called\n"
		"parseL3FormulaWithSettings().  This Avogadro-related functionality is\n"
		"provided because SBML Level 2 models may not use AST_NAME_AVOGADRO AST\n"
		"nodes.\n"
		"\n"
		"Parameter 'tree' is the AST to be converted.\n"
		"\n"
		"Returns the formula from the given AST as text string, with a syntax\n"
		"oriented towards the capabilities defined in SBML Level 3.  The caller\n"
		"owns the returned string and is responsible for freeing it when it is\n"
		"no longer needed.  If 'tree' is a null pointer, then a null pointer is\n"
		"returned.\n"
		"\n"
		"See also formulaToL3StringWithSettings(), formulaToString(),\n"
		"parseL3FormulaWithSettings(), parseL3FormulaWithModel(),\n"
		"parseFormula(), L3ParserSettings, getDefaultL3ParserSettings(),\n"
		"getLastParseL3Error().\n"
		"\n"
		""},
	 { "formulaToL3StringWithSettings", _wrap_formulaToL3StringWithSettings, METH_VARARGS, "\n"
		"formulaToL3StringWithSettings(ASTNode tree, L3ParserSettings settings) -> char *\n"
		"\n"
		"Converts an AST to a text string representation of a formula, using\n"
		"specific formatter settings.\n"
		"\n"
		"This function behaves identically to formulaToL3String() but its\n"
		"behavior is controlled by two fields in the 'settings' object, namely:\n"
		"\n"
		"* parseunits ('parse units'): If this field in the 'settings'\n"
		"object is set to true (the default), the function will write out the\n"
		"units of any numerical ASTNodes that have them, producing (for\n"
		"example) \"3 mL\", \"(3/4) m\", or \"5.5e-10 M\".  If this is set to\n"
		"false, this function will only write out the number itself (\"3\",\n"
		"\"(3/4)\", and \"5.5e-10\", in the previous examples).\n"
		"\n"
		"* collapseminus ('collapse minus'): If this field in the 'settings'\n"
		"object is set to false (the default), the function will write out\n"
		"explicitly any doubly-nested unary minus ASTNodes, producing (for\n"
		"example) \"- -x\" or even \"- - - - -3.1\".  If this is set to true,\n"
		"the function will collapse the nodes before producing the infix form,\n"
		"producing \"x\" and \"-3.1\" in the previous examples.\n"
		"\n"
		"All the other settings of the L3ParserSettings object passed in as\n"
		"'settings' will be ignored for the purposes of this function: the\n"
		"parselog ('parse log') setting is ignored so that \"log10(x)\",\n"
		"\"ln(x)\", and \"log(x, y)\" are always produced; the avocsymbol\n"
		"('Avogadro csymbol') is irrelevant to the behavior of this function;\n"
		"and nothing in the Model object set via the model setting is used.\n"
		"\n"
		"Parameter 'tree' is the AST to be converted. Parameter 'settings' is\n"
		"the L3ParserSettings object used to modify the behavior of this\n"
		"function.\n"
		"\n"
		"Returns the formula from the given AST as text string, with a syntax\n"
		"oriented towards the capabilities defined in SBML Level 3.  The caller\n"
		"owns the returned string and is responsible for freeing it when it is\n"
		"no longer needed.  If 'tree' is a null pointer, then a null pointer is\n"
		"returned.\n"
		"\n"
		"See also formulaToL3String(), formulaToString(),\n"
		"parseL3FormulaWithSettings(), parseL3FormulaWithModel(),\n"
		"parseFormula(), L3ParserSettings, getDefaultL3ParserSettings(),\n"
		"getLastParseL3Error().\n"
		"\n"
		""},
	 { "formulaToString", _wrap_formulaToString, METH_O, "\n"
		"formulaToString(ASTNode tree) -> char *\n"
		"\n"
		"Converts an AST to a string representation of a formula using a syntax\n"
		"basically derived from SBML Level 1.\n"
		"\n"
		"The text-string form of mathematical formulas produced by\n"
		"formulaToString() and read by parseFormula() use a simple C-inspired\n"
		"infix notation taken from SBML Level 1.  A formula in this text-string\n"
		"form therefore can be handed to a program that understands SBML Level\n"
		"1 mathematical expressions, or used as part of a formula translation\n"
		"system. The syntax is described in detail in the documentation for\n"
		"ASTNode.  The following are illustrative examples of formulas\n"
		"expressed using this syntax:\n"
		"\n"
		"  0.10 * k4^2\n"
		"\n"
		"  (vm * s1)/(km + s1)\n"
		"\n"
		"Note that this facility is provided as a convenience by libSBML---the\n"
		"MathML standard does not actually define a 'string-form' equivalent to\n"
		"MathML expression trees, so the choice of formula syntax is somewhat\n"
		"arbitrary.  The approach taken by libSBML is to use the syntax defined\n"
		"by SBML Level 1 (which in fact used a text-string representation of\n"
		"formulas and not MathML).  This formula syntax is based mostly on C\n"
		"programming syntax, and may contain operators, function calls,\n"
		"symbols, and white space characters.  The following table provides the\n"
		"precedence rules for the different entities that may appear in formula\n"
		"strings.\n"
		"\n"
		"  +--------------+---------------------+---------+------------+------------+\n"
		"  | Token        | Operation           | Class   | Precedence | Associates |\n"
		"  +--------------+---------------------+---------+------------+------------+\n"
		"  | name         | symbol reference    | operand | 6          | n/a        |\n"
		"  | (expression) | expression grouping | operand | 6          | n/a        |\n"
		"  | f(...)       | function call       | prefix  | 6          | left       |\n"
		"  | -            | negation            | unary   | 5          | right      |\n"
		"  | ^            | power               | binary  | 4          | left       |\n"
		"  | *            | multiplication      | binary  | 3          | left       |\n"
		"  | /            | divison             | binary  | 3          | left       |\n"
		"  | +            | addition            | binary  | 2          | left       |\n"
		"  | -            | subtraction         | binary  | 2          | left       |\n"
		"  | ,            | argument delimiter  | binary  | 1          | left       |\n"
		"  +--------------+---------------------+---------+------------+------------+\n"
		"\n"
		"In the table above, operand implies the construct is an operand,\n"
		"prefix implies the operation is applied to the following arguments,\n"
		"unary implies there is one argument, and binary implies there are two\n"
		"arguments.  The values in the Precedence column show how the order of\n"
		"different types of operation are determined.  For example, the\n"
		"expression a * b + c is evaluated as (a * b) + c because the '*'\n"
		"operator has higher precedence.  The Associates column shows how the\n"
		"order of similar precedence operations is determined; for example, a -\n"
		"b + c is evaluated as (a - b) + c because the '+' and '-' operators\n"
		"are left-associative.\n"
		"\n"
		"The function call syntax consists of a function name, followed by\n"
		"optional white space, followed by an opening parenthesis token,\n"
		"followed by a sequence of zero or more arguments separated by commas\n"
		"(with each comma optionally preceded and/or followed by zero or more\n"
		"white space characters, followed by a closing parenthesis token.  The\n"
		"function name must be chosen from one of the pre-defined functions in\n"
		"SBML or a user-defined function in the model.  The following table\n"
		"lists the names of certain common mathematical functions; this table\n"
		"corresponds to Table 6 in the SBML Level 1 Version 2 specification:\n"
		"\n"
		"  +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+\n"
		"  | Name  | Args | Formula or meaning                                                | Argument Constraints           | Result constraints |\n"
		"  +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+\n"
		"  | abs   | x    | absolute value of x                                               |                                |                    |\n"
		"  | acos  | x    | arc cosine of x in radians                                        | -1.0 <= x <= 1.0               | 0 <= acos(x) <= Pi |\n"
		"  | asin  | x    | arc sine of x in radians                                          | -1.0 <= x <= 1.0               | 0 <= asin(x) <= Pi |\n"
		"  | atan  | x    | arc tangent of x in radians                                       |                                | 0 <= atan(x) <= Pi |\n"
		"  | ceil  | x    | smallest number not less than x whose value is an exact integer   |                                |                    |\n"
		"  | cos   | x    | cosine of x                                                       |                                |                    |\n"
		"  | exp   | x    | e^x, where e is the base of the natural logarithm                 |                                |                    |\n"
		"  | floor | x    | largest number not greater than x whose value is an exact integer |                                |                    |\n"
		"  | log   | x    | natural logarithm of x                                            | x > 0                          |                    |\n"
		"  | log10 | x    | base 10 logarithm of x                                            | x > 0                          |                    |\n"
		"  | pow   | x, y | x^y                                                               |                                |                    |\n"
		"  | sqr   | x    | x^2                                                               |                                |                    |\n"
		"  | sqrt  | x    | &radic;x                                                          | x > 0                          | sqrt(x) >= 0       |\n"
		"  | sin   | x    | sine of x                                                         |                                |                    |\n"
		"  | tan   | x    | tangent of x                                                      | x != n*Pi/2, for odd integer n |                    |\n"
		"  +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+\n"
		"\n"
		"WARNING:\n"
		"\n"
		"There are differences between the symbols used to represent the common\n"
		"mathematical functions and the corresponding MathML token names.  This\n"
		"is a potential source of incompatibilities. Note in particular that in\n"
		"this text-string syntax, log(x) represents the natural logarithm,\n"
		"whereas in MathML, the natural logarithm is <ln/>.  Application\n"
		"writers are urged to be careful when translating between text forms\n"
		"and MathML forms, especially if they provide a direct text-string\n"
		"input facility to users of their software systems.\n"
		"\n"
		"Note: Callers using SBML Level 3 are encouraged to use the facilities\n"
		"provided by libSBML's newer and more powerful Level 3-oriented formula\n"
		"parser and formatter.  The entry points to this second system are\n"
		"parseL3Formula() and formulaToL3String().  The Level 1-oriented system\n"
		"(i.e., what is provided by formulaToString() and parseFormula()) is\n"
		"provided untouched for backwards compatibility.\n"
		"\n"
		"Parameter 'tree' is the AST to be converted.\n"
		"\n"
		"Returns the formula from the given AST as an SBML Level 1 text-string\n"
		"mathematical formula.  The caller owns the returned string and is\n"
		"responsible for freeing it when it is no longer needed.\n"
		"\n"
		"See also formulaToL3String(), formulaToL3StringWithSettings(),\n"
		"parseL3FormulaWithSettings(), parseL3FormulaWithModel(),\n"
		"parseFormula().\n"
		"\n"
		"Note: We urge developers to keep in mind that the text-string formula\n"
		"syntax is specific to libSBML.  Neither MathML nor SBML define a text-\n"
		"string format for mathematical formulas. LibSBML's particular syntax\n"
		"should not be considered to be a canonical or standard general-purpose\n"
		"mathematical expression syntax.  LibSBML provides methods for parsing\n"
		"and transforming text-string math formulas back and forth from AST\n"
		"structures for the convenience of calling applications, but it is\n"
		"important to keep the system's limitations in mind.\n"
		"\n"
		""},
	 { "parseL3Formula", _wrap_parseL3Formula, METH_O, "\n"
		"parseL3Formula(char const * formula) -> ASTNode\n"
		"\n"
		"Parses a text string as a mathematical formula and returns an AST\n"
		"representation of it.\n"
		"\n"
		"The text-string form of mathematical formulas read by the function\n"
		"parseL3Formula() and written by the function formulaToL3String() uses\n"
		"an expanded version of the syntax read and written by parseFormula()\n"
		"and formulaToString(), respectively.  The latter two libSBML functions\n"
		"were originally developed to support conversion between SBML Levels 1\n"
		"and 2, and were focused on the syntax of mathematical formulas used in\n"
		"SBML Level 1.  With time, and the use of MathML in SBML Levels 2 and\n"
		"3, it became clear that supporting Level 2 and 3's expanded\n"
		"mathematical syntax would be useful for software developers.  To\n"
		"maintain backwards compatibility for libSBML users, the original\n"
		"formulaToString() and parseFormula() have been left untouched, and\n"
		"instead, the new functionality is provided in the form of\n"
		"parseL3Formula() and formulaToL3String().\n"
		"\n"
		"The following lists the main differences in the formula syntax\n"
		"supported by the Level 3 ('L3') versions of the formula parsers and\n"
		"formatters, compared to what is supported by the Level 1-oriented\n"
		"parseFormula() and formulaToString():\n"
		"\n"
		"* Units may be asociated with bare numbers, using the following\n"
		"syntax:\n"
		"\n"
		"number unit\n"
		"\n"
		"The number may be in any form (an integer, real, or rational number),\n"
		"and the unit must conform to the syntax of an SBML identifier\n"
		"(technically, the type defined as 'SId' in the SBML specifications).\n"
		"The whitespace between number and unit is optional.\n"
		"\n"
		"* The Boolean function symbols '&&' (and), '||' (or), '!' (not),\n"
		"and '!=' (not equals) may be used.\n"
		"\n"
		"* The modulo operation is allowed as the symbol '%' and will\n"
		"produce a <piecewise> function in the corresponding MathML output by\n"
		"default, or can produce the MathML function 'rem,'  depending on the\n"
		"L3ParserSettings object (see  L3ParserSettings_setParseModuloL3v2() ).\n"
		"\n"
		"* All inverse trigonometric functions may be defined in the infix\n"
		"either using 'arc' as a prefix or simply 'a;' in other words, both\n"
		"'arccsc' and 'acsc' are interpreted as the operator arccosecant as\n"
		"defined in MathML 2.0.  (Many functions in the simpler SBML Level 1\n"
		"oriented parser implemented by parseFormula() are defined this way as\n"
		"well, but not all.)\n"
		"\n"
		"* The following expression is parsed as a rational number instead\n"
		"of as a numerical division:\n"
		"\n"
		"  (integer/integer)\n"
		"\n"
		"Spaces are not allowed in this construct; in other words, \"(3 / 4)\"\n"
		"(with whitespace between the numbers and the operator) will be parsed\n"
		"into the MathML <divide> construct rather than a rational number.  You\n"
		"can, however, assign units to a rational number as a whole; here is an\n"
		"example: \"(3/4) ml\". (In the case of division rather than a rational\n"
		"number, units are not interpreted in this way.)\n"
		"\n"
		"* Various parser and formatter behaviors may be altered through\n"
		"the use of a L3ParserSettings object in conjunction with the functions\n"
		"parseL3FormulaWithSettings() and formulaToL3StringWithSettings() The\n"
		"settings available include the following:\n"
		"\n"
		"* The function 'log' with a single argument (\"log(x)\") can be parsed\n"
		"as log10(x), ln(x), or treated as an error, as desired.\n"
		"\n"
		"* Unary minus signs can be collapsed or preserved; that is, sequential\n"
		"pairs of unary minuses (e.g., \"- -3\") can be removed from the input\n"
		"entirely and single unary minuses can be incorporated into the number\n"
		"node, or all minuses can be preserved in the AST node structure.\n"
		"\n"
		"* Parsing of units embedded in the input string can be turned on and\n"
		"off.\n"
		"\n"
		"* The string 'avogadro' can be parsed as a MathML csymbol or as an\n"
		"identifier.\n"
		"\n"
		"* The string % can be parsed either as a  piecewise function or as the\n"
		"'rem' function:  a % b will either become\n"
		"\n"
		"piecewise(a - b*ceil(a/b), xor((a < 0), (b < 0)), a - b*floor(a/b))\n"
		"\n"
		"or\n"
		"\n"
		"rem(a, b).\n"
		"\n"
		"The latter is simpler, but the 'rem' MathML is only allowed as of SBML\n"
		"Level 3 Version 2.* A Model object may optionally be provided to the\n"
		"parser using the variant function call parseL3FormulaWithModel() or\n"
		"stored in a L3ParserSettings object passed to the variant function\n"
		"parseL3FormulaWithSettings().  When a Model object is provided,\n"
		"identifiers (values of type 'SId' ) from that model are used in\n"
		"preference to pre-defined MathML definitions for both symbols and\n"
		"functions. More precisely:\n"
		"\n"
		"* In the case of symbols: the Model entities whose identifiers will\n"
		"shadow identical symbols in the mathematical formula are: Species,\n"
		"Compartment, Parameter, Reaction, and SpeciesReference.  For instance,\n"
		"if the parser is given a Model containing a Species with the\n"
		"identifier \"pi\", and the formula to be parsed is \"3*pi\", the\n"
		"MathML produced will contain the construct <ci> pi </ci> instead of\n"
		"the construct <pi/>.\n"
		"\n"
		"* In the case of user-defined functions: when a Model object is\n"
		"provided, 'SId' values of user-defined functions present in the model\n"
		"will be used preferentially over pre-defined MathML functions.  For\n"
		"example, if the passed-in Model contains a FunctionDefinition object\n"
		"with the identifier \"sin\", that function will be used instead of the\n"
		"predefined MathML function <sin/>.\n"
		"\n"
		"* An SBMLNamespaces object may optionally be provided to identify\n"
		"SBML Level 3 packages that extend the syntax understood by the formula\n"
		"parser.  When the namespaces are provided, the parser will interpret\n"
		"possible additional syntax defined by the libSBML plug-ins\n"
		"implementing the SBML Level 3 packages; for example, it may understand\n"
		"vector/array extensions introduced by the SBML Level 3 Arrays package.\n"
		"These configuration settings cannot be changed directly using the\n"
		"basic parser and formatter functions, but can be changed on a per-call\n"
		"basis by using the alternative functions parseL3FormulaWithSettings()\n"
		"and formulaToL3StringWithSettings().\n"
		"\n"
		"Neither SBML nor the MathML standard define a 'string-form' equivalent\n"
		"to MathML expressions.  The approach taken by libSBML is to start with\n"
		"the formula syntax defined by SBML Level 1 (which in fact used a\n"
		"custom text-string representation of formulas, and not MathML), and\n"
		"expand it to include the functionality described above.  This formula\n"
		"syntax is based mostly on C programming syntax, and may contain\n"
		"operators, function calls, symbols, and white space characters.  The\n"
		"following table provides the precedence rules for the different\n"
		"entities that may appear in formula strings.\n"
		"\n"
		"  +----------------------+--------------------------+---------+---------+--------+\n"
		"  | Token                | Operation                | Class   | Preced. | Assoc. |\n"
		"  +----------------------+--------------------------+---------+---------+--------+\n"
		"  | name                 | symbol reference         | operand | 8       | n/a    |\n"
		"  | (expression)         | expression grouping      | operand | 8       | n/a    |\n"
		"  | f(...)               | function call            | prefix  | 8       | left   |\n"
		"  | ^                    | power                    | binary  | 7       | left   |\n"
		"  | -, !                 | negation, Boolean 'not'  | unary   | 6       | right  |\n"
		"  | *, /, %              | multip., div., modulo    | binary  | 5       | left   |\n"
		"  | +, -                 | addition and subtraction | binary  | 4       | left   |\n"
		"  | ==, <, >, <=, >=, != | Boolean comparisons      | binary  | 3       | left   |\n"
		"  | &&, ||               | Boolean 'and' and 'or'   | binary  | 2       | left   |\n"
		"  | ,                    | argument delimiter       | binary  | 1       | left   |\n"
		"  +----------------------+--------------------------+---------+---------+--------+\n"
		"\n"
		"In the table above, operand implies the construct is an operand,\n"
		"prefix implies the operation is applied to the following arguments,\n"
		"unary implies there is one argument, and binary implies there are two\n"
		"arguments.  The values in the Precedence column show how the order of\n"
		"different types of operation are determined.  For example, the\n"
		"expression a + b * c is evaluated as a + (b * c) because the '*'\n"
		"operator has higher precedence.  The Associates column shows how the\n"
		"order of similar precedence operations is determined; for example, a\n"
		"&& b || c is evaluated as (a && b) || c because the '&&' and '||'\n"
		"operators are left-associative and have the same precedence.\n"
		"\n"
		"The function call syntax consists of a function name, followed by\n"
		"optional white space, followed by an opening parenthesis token,\n"
		"followed by a sequence of zero or more arguments separated by commas\n"
		"(with each comma optionally preceded and/or followed by zero or more\n"
		"white space characters), followed by a closing parenthesis token.  The\n"
		"function name must be chosen from one of the pre-defined functions in\n"
		"SBML or a user-defined function in the model.  The following table\n"
		"lists the names of certain common mathematical functions; this table\n"
		"corresponds to Table 6 in the SBML Level 1 Version 2 specification\n"
		"with additions based on the functions added in SBML Level 2 and Level\n"
		"3:\n"
		"\n"
		"  +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+\n"
		"  | Name           | Argument(s)                 | Formula or meaning                                                                                                                                                                    | Argument Constraints             | Result constraints |\n"
		"  +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+\n"
		"  | abs            | x                           | Absolute value of x.                                                                                                                                                                  |                                  |                    |\n"
		"  | acos, arccos   | x                           | Arccosine of x in radians.                                                                                                                                                            | -1.0 <= x <= 1.0                 | 0 <= acos(x) <= Pi |\n"
		"  | acosh, arccosh | x                           | Hyperbolic arccosine of x in radians.                                                                                                                                                 |                                  |                    |\n"
		"  | acot, arccot   | x                           | Arccotangent of x in radians.                                                                                                                                                         |                                  |                    |\n"
		"  | acoth, arccoth | x                           | Hyperbolic arccotangent of x in radians.                                                                                                                                              |                                  |                    |\n"
		"  | acsc, arccsc   | x                           | Arccosecant of x in radians.                                                                                                                                                          |                                  |                    |\n"
		"  | acsch, arccsch | x                           | Hyperbolic arccosecant of x in radians.                                                                                                                                               |                                  |                    |\n"
		"  | asec, arcsec   | x                           | Arcsecant of x in radians.                                                                                                                                                            |                                  |                    |\n"
		"  | asech, arcsech | x                           | Hyperbolic arcsecant of x in radians.                                                                                                                                                 |                                  |                    |\n"
		"  | asin, arcsin   | x                           | Arcsine of x in radians.                                                                                                                                                              | -1.0 <= x <= 1.0                 | 0 <= asin(x) <= Pi |\n"
		"  | atan, arctan   | x                           | Arctangent of x in radians.                                                                                                                                                           |                                  | 0 <= atan(x) <= Pi |\n"
		"  | atanh, arctanh | x                           | Hyperbolic arctangent of x in radians.                                                                                                                                                |                                  |                    |\n"
		"  | ceil, ceiling  | x                           | Smallest number not less than x whose value is an exact integer.                                                                                                                      |                                  |                    |\n"
		"  | cos            | x                           | Cosine of x                                                                                                                                                                           |                                  |                    |\n"
		"  | cosh           | x                           | Hyperbolic cosine of x.                                                                                                                                                               |                                  |                    |\n"
		"  | cot            | x                           | Cotangent of x.                                                                                                                                                                       |                                  |                    |\n"
		"  | coth           | x                           | Hyperbolic cotangent of x.                                                                                                                                                            |                                  |                    |\n"
		"  | csc            | x                           | Cosecant of x.                                                                                                                                                                        |                                  |                    |\n"
		"  | csch           | x                           | Hyperbolic cosecant of x.                                                                                                                                                             |                                  |                    |\n"
		"  | delay          | x, y                        | The value of x at y time units in the past.                                                                                                                                           |                                  |                    |\n"
		"  | factorial      | n                           | The factorial of n. Factorials are defined by n! = n*(n-1)* ... * 1.                                                                                                                  | n must be an integer.            |                    |\n"
		"  | exp            | x                           | e^x, where e is the base of the natural logarithm.                                                                                                                                    |                                  |                    |\n"
		"  | floor          | x                           | The largest number not greater than x whose value is an exact integer.                                                                                                                |                                  |                    |\n"
		"  | ln             | x                           | Natural logarithm of x.                                                                                                                                                               | x > 0                            |                    |\n"
		"  | 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                            |                    |\n"
		"  | log            | x, y                        | The base x logarithm of y.                                                                                                                                                            | y > 0                            |                    |\n"
		"  | log10          | x                           | Base 10 logarithm of x.                                                                                                                                                               | x > 0                            |                    |\n"
		"  | 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 |                    |\n"
		"  | pow, power     | x, y                        | x^y.                                                                                                                                                                                  |                                  |                    |\n"
		"  | root           | b, x                        | The root base b of x.                                                                                                                                                                 |                                  |                    |\n"
		"  | sec            | x                           | Secant of x.                                                                                                                                                                          |                                  |                    |\n"
		"  | sech           | x                           | Hyperbolic secant of x.                                                                                                                                                               |                                  |                    |\n"
		"  | sqr            | x                           | x^2.                                                                                                                                                                                  |                                  |                    |\n"
		"  | sqrt           | x                           | &radic;x.                                                                                                                                                                             | x > 0                            | sqrt(x) >= 0       |\n"
		"  | sin            | x                           | Sine of x.                                                                                                                                                                            |                                  |                    |\n"
		"  | sinh           | x                           | Hyperbolic sine of x.                                                                                                                                                                 |                                  |                    |\n"
		"  | tan            | x                           | Tangent of x.                                                                                                                                                                         | x != n*Pi/2, for odd integer n   |                    |\n"
		"  | tanh           | x                           | Hyperbolic tangent of x.                                                                                                                                                              |                                  |                    |\n"
		"  | 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    |                    |\n"
		"  | not            | x                           | Boolean not(x)                                                                                                                                                                        | x must be Boolean                |                    |\n"
		"  | 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    |                    |\n"
		"  | 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    |                    |\n"
		"  | 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.                                               |                                  |                    |\n"
		"  | 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. |                                  |                    |\n"
		"  | 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.               |                                  |                    |\n"
		"  | 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.    |                                  |                    |\n"
		"  | 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.                  |                                  |                    |\n"
		"  | neq            | x, y                        | Boolean x != y: returns true unless x and y are equal.                                                                                                                                |                                  |                    |\n"
		"  | 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.                                |                                  |                    |\n"
		"  | 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.                          |                                  |                    |\n"
		"  | minus          | x, y                        | x - y.                                                                                                                                                                                |                                  |                    |\n"
		"  | divide         | x, y                        | x / y.                                                                                                                                                                                |                                  |                    |\n"
		"  +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+\n"
		"\n"
		"Parsing of the various MathML functions and constants are all case-\n"
		"insensitive by default: function names such as cos, Cos and COS are\n"
		"all parsed as the MathML cosine operator, <cos>.  However, when a\n"
		"Model object is used in conjunction with either\n"
		"parseL3FormulaWithModel() or parseL3FormulaWithSettings(), any\n"
		"identifiers found in that model will be parsed in a case-sensitive\n"
		"way.  For example, if a model contains a Species having the identifier\n"
		"Pi, the parser will parse \"Pi\" in the input as \"<ci> Pi </ci>\" but\n"
		"will continue to parse the symbols \"pi\" and \"PI\" as \"<pi>\".\n"
		"\n"
		"As mentioned above, the manner in which the 'L3' versions of the\n"
		"formula parser and formatter interpret the function \"log\" can be\n"
		"changed.  To do so, callers should use the function\n"
		"parseL3FormulaWithSettings() and pass it an appropriate\n"
		"L3ParserSettings object.  By default, unlike the SBML Level 1 parser\n"
		"implemented by parseFormula(), the string \"log\" is interpreted as\n"
		"the base 10 logarithm, and not as the natural logarithm.  However, you\n"
		"can change the interpretation to be base-10 log, natural log, or as an\n"
		"error; since the name 'log' by itself is ambiguous, you require that\n"
		"the parser uses 'log10' or 'ln' instead, which are more clear.  Please\n"
		"refer to parseL3FormulaWithSettings().\n"
		"\n"
		"In addition, the following symbols will be translated to their MathML\n"
		"equivalents, if no symbol with the same 'SId' identifier string exists\n"
		"in the Model object provided:\n"
		"\n"
		"  +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+\n"
		"  | Name            | Meaning                                         | MathML                                                                                                       |\n"
		"  +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+\n"
		"  | true            | Boolean value true                              | <true/>                                                                                                      |\n"
		"  | false           | Boolean value false                             | <false/>                                                                                                     |\n"
		"  | pi              | Mathematical constant pi                        | <pi/>                                                                                                        |\n"
		"  | avogadro        | Value of Avogadro's constant stipulated by SBML | <csymbol encoding=\"text\" definitionURL=\"http://www.sbml.org/sbml/symbols/avogadro\"> avogadro </csymbol/> |\n"
		"  | time            | Simulation time as defined in SBML              | <csymbol encoding=\"text\" definitionURL=\"http://www.sbml.org/sbml/symbols/time\"> time </csymbol/>         |\n"
		"  | inf, infinity   | Mathematical constant \"infinity\"              | <infinity/>                                                                                                  |\n"
		"  | nan, notanumber | Mathematical concept \"not a number\"           | <notanumber/>                                                                                                |\n"
		"  +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+\n"
		"\n"
		"Again, as mentioned above, whether the string \"avogadro\" is parsed\n"
		"as an AST node of type AST_NAME_AVOGADRO or AST_NAME is configurable;\n"
		"use the version of the parser function called\n"
		"parseL3FormulaWithSettings().  This Avogadro-related functionality is\n"
		"provided because SBML Level 2 models may not use AST_NAME_AVOGADRO AST\n"
		"nodes.\n"
		"\n"
		"Parameter 'formula' is the text-string formula expression to be\n"
		"parsed.\n"
		"\n"
		"Returns the root node of an AST representing the mathematical formula,\n"
		"or 'None' if an error occurred while parsing the formula.  When 'None'\n"
		"is returned, an error is recorded internally; information about the\n"
		"error can be retrieved using getLastParseL3Error().\n"
		"\n"
		"See also parseL3FormulaWithSettings(), parseL3FormulaWithModel(),\n"
		"parseFormula(), formulaToL3StringWithSettings(), formulaToL3String(),\n"
		"formulaToString(), L3ParserSettings, getDefaultL3ParserSettings(),\n"
		"getLastParseL3Error().\n"
		"\n"
		"Note: We urge developers to keep in mind that the text-string formula\n"
		"syntax is specific to libSBML.  Neither MathML nor SBML define a text-\n"
		"string format for mathematical formulas. LibSBML's particular syntax\n"
		"should not be considered to be a canonical or standard general-purpose\n"
		"mathematical expression syntax.  LibSBML provides methods for parsing\n"
		"and transforming text-string math formulas back and forth from AST\n"
		"structures for the convenience of calling applications, but it is\n"
		"important to keep the system's limitations in mind.\n"
		"\n"
		""},
	 { "parseL3FormulaWithModel", _wrap_parseL3FormulaWithModel, METH_VARARGS, "\n"
		"parseL3FormulaWithModel(char const * formula, Model model) -> ASTNode\n"
		"\n"
		"Parses a text string as a mathematical formula using a Model to\n"
		"resolve symbols, and returns an AST representation of the result.\n"
		"\n"
		"This is identical to parseL3Formula(), except that this function uses\n"
		"the given model in the argument 'model' to check against identifiers\n"
		"that appear in the 'formula'.  For more information about the parser,\n"
		"please see the definition of L3ParserSettings and the function\n"
		"parseL3Formula().\n"
		"\n"
		"Parameter 'formula' is the mathematical formula expression to be\n"
		"parsed.\n"
		"\n"
		"Parameter 'model' is the Model object to use for checking identifiers.\n"
		"\n"
		"Returns the root node of an AST representing the mathematical formula,\n"
		"or 'None' if an error occurred while parsing the formula.  When 'None'\n"
		"is returned, an error is recorded internally; information about the\n"
		"error can be retrieved using getLastParseL3Error().\n"
		"\n"
		"See also parseL3Formula(), parseL3FormulaWithSettings(),\n"
		"parseL3FormulaWithModel(), parseFormula(), getLastParseL3Error(),\n"
		"L3ParserSettings.\n"
		"\n"
		""},
	 { "parseL3FormulaWithSettings", _wrap_parseL3FormulaWithSettings, METH_VARARGS, "\n"
		"parseL3FormulaWithSettings(char const * formula, L3ParserSettings settings) -> ASTNode\n"
		"\n"
		"Parses a text string as a mathematical formula using specific parser\n"
		"settings and returns an AST representation of the result.\n"
		"\n"
		"This is identical to parseL3Formula(), except that this function uses\n"
		"the parser settings given in the argument 'settings'.  The settings\n"
		"override the default parsing behavior.  The following parsing\n"
		"behaviors can be configured:\n"
		"\n"
		"* A Model object may optionally be provided to use identifiers\n"
		"(values of type 'SId)' from the model in preference to pre-defined\n"
		"MathML symbols More precisely, the Model entities whose identifiers\n"
		"will shadow identical symbols in the mathematical formula are:\n"
		"Species, Compartment, Parameter, Reaction, and SpeciesReference.  For\n"
		"instance, if the parser is given a Model containing a Species with the\n"
		"identifier \"pi\", and the formula to be parsed is \"3*pi\", the\n"
		"MathML produced by the parser will contain the construct <ci> pi </ci>\n"
		"instead of the construct <pi/>.  Another example, if the passed-in\n"
		"Model contains a FunctionDefinition with the identifier \"sin\", that\n"
		"function will be used instead of the predefined MathML function\n"
		"<sin/>.\n"
		"\n"
		"* The function 'log' with a single argument (\"log(x)\") can be\n"
		"parsed as log10(x), ln(x), or treated as an error, as desired.\n"
		"\n"
		"* Unary minus signs can be either collapsed or preserved; that is,\n"
		"the parser can either (1) remove sequential pairs of unary minuses\n"
		"(e.g., \"- -3\") from the input and incorporate single unary minuses\n"
		"into the number node, or (2) preserve all minuses in the AST node\n"
		"structure, turning them into ASTNode objects of type AST_MINUS.\n"
		"\n"
		"* The character sequence \"number id\" can be interpreted as a\n"
		"numerical value 'number' followed by units of measurement indicated by\n"
		"'id,' or it can be treated as a syntax error.  (In Level 3, MathML\n"
		"<cn> elements can have an attribute named 'units' placed in the SBML\n"
		"namespace, which can be used to indicate the units to be associated\n"
		"with the number.  The text-string infix formula parser allows units to\n"
		"be placed after raw numbers; they are interpreted as unit identifiers\n"
		"for units defined by the SBML specification or in the containing Model\n"
		"object.)\n"
		"\n"
		"* The symbol 'avogadro' can be parsed either as a MathML csymbol or\n"
		"as a identifier.  More specifically, \"avogadro\" can be treated as an\n"
		"ASTNode of type AST_NAME_AVOGADRO or of type AST_NAME.\n"
		"\n"
		"* Strings that match built-in functions and constants can either be\n"
		"parsed as a match regardless of capitalization, or may be required to\n"
		"be all-lower-case to be considered a match.\n"
		"\n"
		"* LibSBML plug-ins implementing support for SBML Level 3 packages\n"
		"may introduce extensions to the syntax understood by the parser.  The\n"
		"precise nature of the extensions will be documented by the individual\n"
		"package plug-ins.  An example of a possible extension is a notation\n"
		"for vectors and arrays, introduced by the SBML Level 3 Arrays package.\n"
		"\n"
		"For more details about the parser, please see the definition of\n"
		"L3ParserSettings and parseL3FormulaWithSettings().\n"
		"\n"
		"Parameter 'formula' is the mathematical formula expression to be\n"
		"parsed.\n"
		"\n"
		"Parameter 'settings' is the settings to be used for this parser\n"
		"invocation.\n"
		"\n"
		"Returns the root node of an AST representing the mathematical formula,\n"
		"or 'None' if an error occurred while parsing the formula.  When 'None'\n"
		"is returned, an error is recorded internally; information about the\n"
		"error can be retrieved using getLastParseL3Error().\n"
		"\n"
		"See also parseL3Formula(), parseL3FormulaWithSettings(),\n"
		"parseL3FormulaWithModel(), parseFormula(), getLastParseL3Error(),\n"
		"L3ParserSettings.\n"
		"\n"
		""},
	 { "getDefaultL3ParserSettings", _wrap_getDefaultL3ParserSettings, METH_NOARGS, "\n"
		"getDefaultL3ParserSettings() -> L3ParserSettings\n"
		"\n"
		"Returns a copy of the default Level 3 ('L3') formula parser settings.\n"
		"\n"
		"The data structure storing the settings allows callers to change the\n"
		"following parsing behaviors:\n"
		"\n"
		"The text-string form of mathematical formulas read by the function\n"
		"parseL3Formula() and written by the function formulaToL3String() uses\n"
		"an expanded version of the syntax read and written by parseFormula()\n"
		"and formulaToString(), respectively.  The latter two libSBML functions\n"
		"were originally developed to support conversion between SBML Levels 1\n"
		"and 2, and were focused on the syntax of mathematical formulas used in\n"
		"SBML Level 1.  With time, and the use of MathML in SBML Levels 2 and\n"
		"3, it became clear that supporting Level 2 and 3's expanded\n"
		"mathematical syntax would be useful for software developers.  To\n"
		"maintain backwards compatibility for libSBML users, the original\n"
		"formulaToString() and parseFormula() have been left untouched, and\n"
		"instead, the new functionality is provided in the form of\n"
		"parseL3Formula() and formulaToL3String().\n"
		"\n"
		"The following lists the main differences in the formula syntax\n"
		"supported by the Level 3 ('L3') versions of the formula parsers and\n"
		"formatters, compared to what is supported by the Level 1-oriented\n"
		"parseFormula() and formulaToString():\n"
		"\n"
		"* Units may be asociated with bare numbers, using the following\n"
		"syntax:\n"
		"\n"
		"number unit\n"
		"\n"
		"The number may be in any form (an integer, real, or rational number),\n"
		"and the unit must conform to the syntax of an SBML identifier\n"
		"(technically, the type defined as 'SId' in the SBML specifications).\n"
		"The whitespace between number and unit is optional.\n"
		"\n"
		"* The Boolean function symbols '&&' (and), '||' (or), '!' (not),\n"
		"and '!=' (not equals) may be used.\n"
		"\n"
		"* The modulo operation is allowed as the symbol '%' and will\n"
		"produce a <piecewise> function in the corresponding MathML output by\n"
		"default, or can produce the MathML function 'rem,'  depending on the\n"
		"L3ParserSettings object (see  L3ParserSettings_setParseModuloL3v2() ).\n"
		"\n"
		"* All inverse trigonometric functions may be defined in the infix\n"
		"either using 'arc' as a prefix or simply 'a;' in other words, both\n"
		"'arccsc' and 'acsc' are interpreted as the operator arccosecant as\n"
		"defined in MathML 2.0.  (Many functions in the simpler SBML Level 1\n"
		"oriented parser implemented by parseFormula() are defined this way as\n"
		"well, but not all.)\n"
		"\n"
		"* The following expression is parsed as a rational number instead\n"
		"of as a numerical division:\n"
		"\n"
		"  (integer/integer)\n"
		"\n"
		"Spaces are not allowed in this construct; in other words, \"(3 / 4)\"\n"
		"(with whitespace between the numbers and the operator) will be parsed\n"
		"into the MathML <divide> construct rather than a rational number.  You\n"
		"can, however, assign units to a rational number as a whole; here is an\n"
		"example: \"(3/4) ml\". (In the case of division rather than a rational\n"
		"number, units are not interpreted in this way.)\n"
		"\n"
		"* Various parser and formatter behaviors may be altered through\n"
		"the use of a L3ParserSettings object in conjunction with the functions\n"
		"parseL3FormulaWithSettings() and formulaToL3StringWithSettings() The\n"
		"settings available include the following:\n"
		"\n"
		"* The function 'log' with a single argument (\"log(x)\") can be parsed\n"
		"as log10(x), ln(x), or treated as an error, as desired.\n"
		"\n"
		"* Unary minus signs can be collapsed or preserved; that is, sequential\n"
		"pairs of unary minuses (e.g., \"- -3\") can be removed from the input\n"
		"entirely and single unary minuses can be incorporated into the number\n"
		"node, or all minuses can be preserved in the AST node structure.\n"
		"\n"
		"* Parsing of units embedded in the input string can be turned on and\n"
		"off.\n"
		"\n"
		"* The string 'avogadro' can be parsed as a MathML csymbol or as an\n"
		"identifier.\n"
		"\n"
		"* The string % can be parsed either as a  piecewise function or as the\n"
		"'rem' function:  a % b will either become\n"
		"\n"
		"piecewise(a - b*ceil(a/b), xor((a < 0), (b < 0)), a - b*floor(a/b))\n"
		"\n"
		"or\n"
		"\n"
		"rem(a, b).\n"
		"\n"
		"The latter is simpler, but the 'rem' MathML is only allowed as of SBML\n"
		"Level 3 Version 2.* A Model object may optionally be provided to the\n"
		"parser using the variant function call parseL3FormulaWithModel() or\n"
		"stored in a L3ParserSettings object passed to the variant function\n"
		"parseL3FormulaWithSettings().  When a Model object is provided,\n"
		"identifiers (values of type 'SId' ) from that model are used in\n"
		"preference to pre-defined MathML definitions for both symbols and\n"
		"functions. More precisely:\n"
		"\n"
		"* In the case of symbols: the Model entities whose identifiers will\n"
		"shadow identical symbols in the mathematical formula are: Species,\n"
		"Compartment, Parameter, Reaction, and SpeciesReference.  For instance,\n"
		"if the parser is given a Model containing a Species with the\n"
		"identifier \"pi\", and the formula to be parsed is \"3*pi\", the\n"
		"MathML produced will contain the construct <ci> pi </ci> instead of\n"
		"the construct <pi/>.\n"
		"\n"
		"* In the case of user-defined functions: when a Model object is\n"
		"provided, 'SId' values of user-defined functions present in the model\n"
		"will be used preferentially over pre-defined MathML functions.  For\n"
		"example, if the passed-in Model contains a FunctionDefinition object\n"
		"with the identifier \"sin\", that function will be used instead of the\n"
		"predefined MathML function <sin/>.\n"
		"\n"
		"* An SBMLNamespaces object may optionally be provided to identify\n"
		"SBML Level 3 packages that extend the syntax understood by the formula\n"
		"parser.  When the namespaces are provided, the parser will interpret\n"
		"possible additional syntax defined by the libSBML plug-ins\n"
		"implementing the SBML Level 3 packages; for example, it may understand\n"
		"vector/array extensions introduced by the SBML Level 3 Arrays package.\n"
		"These configuration settings cannot be changed directly using the\n"
		"basic parser and formatter functions, but can be changed on a per-call\n"
		"basis by using the alternative functions parseL3FormulaWithSettings()\n"
		"and formulaToL3StringWithSettings().\n"
		"\n"
		"Neither SBML nor the MathML standard define a 'string-form' equivalent\n"
		"to MathML expressions.  The approach taken by libSBML is to start with\n"
		"the formula syntax defined by SBML Level 1 (which in fact used a\n"
		"custom text-string representation of formulas, and not MathML), and\n"
		"expand it to include the functionality described above.  This formula\n"
		"syntax is based mostly on C programming syntax, and may contain\n"
		"operators, function calls, symbols, and white space characters.  The\n"
		"following table provides the precedence rules for the different\n"
		"entities that may appear in formula strings.\n"
		"\n"
		"  +----------------------+--------------------------+---------+---------+--------+\n"
		"  | Token                | Operation                | Class   | Preced. | Assoc. |\n"
		"  +----------------------+--------------------------+---------+---------+--------+\n"
		"  | name                 | symbol reference         | operand | 8       | n/a    |\n"
		"  | (expression)         | expression grouping      | operand | 8       | n/a    |\n"
		"  | f(...)               | function call            | prefix  | 8       | left   |\n"
		"  | ^                    | power                    | binary  | 7       | left   |\n"
		"  | -, !                 | negation, Boolean 'not'  | unary   | 6       | right  |\n"
		"  | *, /, %              | multip., div., modulo    | binary  | 5       | left   |\n"
		"  | +, -                 | addition and subtraction | binary  | 4       | left   |\n"
		"  | ==, <, >, <=, >=, != | Boolean comparisons      | binary  | 3       | left   |\n"
		"  | &&, ||               | Boolean 'and' and 'or'   | binary  | 2       | left   |\n"
		"  | ,                    | argument delimiter       | binary  | 1       | left   |\n"
		"  +----------------------+--------------------------+---------+---------+--------+\n"
		"\n"
		"In the table above, operand implies the construct is an operand,\n"
		"prefix implies the operation is applied to the following arguments,\n"
		"unary implies there is one argument, and binary implies there are two\n"
		"arguments.  The values in the Precedence column show how the order of\n"
		"different types of operation are determined.  For example, the\n"
		"expression a + b * c is evaluated as a + (b * c) because the '*'\n"
		"operator has higher precedence.  The Associates column shows how the\n"
		"order of similar precedence operations is determined; for example, a\n"
		"&& b || c is evaluated as (a && b) || c because the '&&' and '||'\n"
		"operators are left-associative and have the same precedence.\n"
		"\n"
		"The function call syntax consists of a function name, followed by\n"
		"optional white space, followed by an opening parenthesis token,\n"
		"followed by a sequence of zero or more arguments separated by commas\n"
		"(with each comma optionally preceded and/or followed by zero or more\n"
		"white space characters), followed by a closing parenthesis token.  The\n"
		"function name must be chosen from one of the pre-defined functions in\n"
		"SBML or a user-defined function in the model.  The following table\n"
		"lists the names of certain common mathematical functions; this table\n"
		"corresponds to Table 6 in the SBML Level 1 Version 2 specification\n"
		"with additions based on the functions added in SBML Level 2 and Level\n"
		"3:\n"
		"\n"
		"  +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+\n"
		"  | Name           | Argument(s)                 | Formula or meaning                                                                                                                                                                    | Argument Constraints             | Result constraints |\n"
		"  +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+\n"
		"  | abs            | x                           | Absolute value of x.                                                                                                                                                                  |                                  |                    |\n"
		"  | acos, arccos   | x                           | Arccosine of x in radians.                                                                                                                                                            | -1.0 <= x <= 1.0                 | 0 <= acos(x) <= Pi |\n"
		"  | acosh, arccosh | x                           | Hyperbolic arccosine of x in radians.                                                                                                                                                 |                                  |                    |\n"
		"  | acot, arccot   | x                           | Arccotangent of x in radians.                                                                                                                                                         |                                  |                    |\n"
		"  | acoth, arccoth | x                           | Hyperbolic arccotangent of x in radians.                                                                                                                                              |                                  |                    |\n"
		"  | acsc, arccsc   | x                           | Arccosecant of x in radians.                                                                                                                                                          |                                  |                    |\n"
		"  | acsch, arccsch | x                           | Hyperbolic arccosecant of x in radians.                                                                                                                                               |                                  |                    |\n"
		"  | asec, arcsec   | x                           | Arcsecant of x in radians.                                                                                                                                                            |                                  |                    |\n"
		"  | asech, arcsech | x                           | Hyperbolic arcsecant of x in radians.                                                                                                                                                 |                                  |                    |\n"
		"  | asin, arcsin   | x                           | Arcsine of x in radians.                                                                                                                                                              | -1.0 <= x <= 1.0                 | 0 <= asin(x) <= Pi |\n"
		"  | atan, arctan   | x                           | Arctangent of x in radians.                                                                                                                                                           |                                  | 0 <= atan(x) <= Pi |\n"
		"  | atanh, arctanh | x                           | Hyperbolic arctangent of x in radians.                                                                                                                                                |                                  |                    |\n"
		"  | ceil, ceiling  | x                           | Smallest number not less than x whose value is an exact integer.                                                                                                                      |                                  |                    |\n"
		"  | cos            | x                           | Cosine of x                                                                                                                                                                           |                                  |                    |\n"
		"  | cosh           | x                           | Hyperbolic cosine of x.                                                                                                                                                               |                                  |                    |\n"
		"  | cot            | x                           | Cotangent of x.                                                                                                                                                                       |                                  |                    |\n"
		"  | coth           | x                           | Hyperbolic cotangent of x.                                                                                                                                                            |                                  |                    |\n"
		"  | csc            | x                           | Cosecant of x.                                                                                                                                                                        |                                  |                    |\n"
		"  | csch           | x                           | Hyperbolic cosecant of x.                                                                                                                                                             |                                  |                    |\n"
		"  | delay          | x, y                        | The value of x at y time units in the past.                                                                                                                                           |                                  |                    |\n"
		"  | factorial      | n                           | The factorial of n. Factorials are defined by n! = n*(n-1)* ... * 1.                                                                                                                  | n must be an integer.            |                    |\n"
		"  | exp            | x                           | e^x, where e is the base of the natural logarithm.                                                                                                                                    |                                  |                    |\n"
		"  | floor          | x                           | The largest number not greater than x whose value is an exact integer.                                                                                                                |                                  |                    |\n"
		"  | ln             | x                           | Natural logarithm of x.                                                                                                                                                               | x > 0                            |                    |\n"
		"  | 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                            |                    |\n"
		"  | log            | x, y                        | The base x logarithm of y.                                                                                                                                                            | y > 0                            |                    |\n"
		"  | log10          | x                           | Base 10 logarithm of x.                                                                                                                                                               | x > 0                            |                    |\n"
		"  | 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 |                    |\n"
		"  | pow, power     | x, y                        | x^y.                                                                                                                                                                                  |                                  |                    |\n"
		"  | root           | b, x                        | The root base b of x.                                                                                                                                                                 |                                  |                    |\n"
		"  | sec            | x                           | Secant of x.                                                                                                                                                                          |                                  |                    |\n"
		"  | sech           | x                           | Hyperbolic secant of x.                                                                                                                                                               |                                  |                    |\n"
		"  | sqr            | x                           | x^2.                                                                                                                                                                                  |                                  |                    |\n"
		"  | sqrt           | x                           | &radic;x.                                                                                                                                                                             | x > 0                            | sqrt(x) >= 0       |\n"
		"  | sin            | x                           | Sine of x.                                                                                                                                                                            |                                  |                    |\n"
		"  | sinh           | x                           | Hyperbolic sine of x.                                                                                                                                                                 |                                  |                    |\n"
		"  | tan            | x                           | Tangent of x.                                                                                                                                                                         | x != n*Pi/2, for odd integer n   |                    |\n"
		"  | tanh           | x                           | Hyperbolic tangent of x.                                                                                                                                                              |                                  |                    |\n"
		"  | 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    |                    |\n"
		"  | not            | x                           | Boolean not(x)                                                                                                                                                                        | x must be Boolean                |                    |\n"
		"  | 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    |                    |\n"
		"  | 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    |                    |\n"
		"  | 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.                                               |                                  |                    |\n"
		"  | 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. |                                  |                    |\n"
		"  | 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.               |                                  |                    |\n"
		"  | 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.    |                                  |                    |\n"
		"  | 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.                  |                                  |                    |\n"
		"  | neq            | x, y                        | Boolean x != y: returns true unless x and y are equal.                                                                                                                                |                                  |                    |\n"
		"  | 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.                                |                                  |                    |\n"
		"  | 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.                          |                                  |                    |\n"
		"  | minus          | x, y                        | x - y.                                                                                                                                                                                |                                  |                    |\n"
		"  | divide         | x, y                        | x / y.                                                                                                                                                                                |                                  |                    |\n"
		"  +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+\n"
		"\n"
		"Parsing of the various MathML functions and constants are all case-\n"
		"insensitive by default: function names such as cos, Cos and COS are\n"
		"all parsed as the MathML cosine operator, <cos>.  However, when a\n"
		"Model object is used in conjunction with either\n"
		"parseL3FormulaWithModel() or parseL3FormulaWithSettings(), any\n"
		"identifiers found in that model will be parsed in a case-sensitive\n"
		"way.  For example, if a model contains a Species having the identifier\n"
		"Pi, the parser will parse \"Pi\" in the input as \"<ci> Pi </ci>\" but\n"
		"will continue to parse the symbols \"pi\" and \"PI\" as \"<pi>\".\n"
		"\n"
		"As mentioned above, the manner in which the 'L3' versions of the\n"
		"formula parser and formatter interpret the function \"log\" can be\n"
		"changed.  To do so, callers should use the function\n"
		"parseL3FormulaWithSettings() and pass it an appropriate\n"
		"L3ParserSettings object.  By default, unlike the SBML Level 1 parser\n"
		"implemented by parseFormula(), the string \"log\" is interpreted as\n"
		"the base 10 logarithm, and not as the natural logarithm.  However, you\n"
		"can change the interpretation to be base-10 log, natural log, or as an\n"
		"error; since the name 'log' by itself is ambiguous, you require that\n"
		"the parser uses 'log10' or 'ln' instead, which are more clear.  Please\n"
		"refer to parseL3FormulaWithSettings().\n"
		"\n"
		"In addition, the following symbols will be translated to their MathML\n"
		"equivalents, if no symbol with the same 'SId' identifier string exists\n"
		"in the Model object provided:\n"
		"\n"
		"  +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+\n"
		"  | Name            | Meaning                                         | MathML                                                                                                       |\n"
		"  +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+\n"
		"  | true            | Boolean value true                              | <true/>                                                                                                      |\n"
		"  | false           | Boolean value false                             | <false/>                                                                                                     |\n"
		"  | pi              | Mathematical constant pi                        | <pi/>                                                                                                        |\n"
		"  | avogadro        | Value of Avogadro's constant stipulated by SBML | <csymbol encoding=\"text\" definitionURL=\"http://www.sbml.org/sbml/symbols/avogadro\"> avogadro </csymbol/> |\n"
		"  | time            | Simulation time as defined in SBML              | <csymbol encoding=\"text\" definitionURL=\"http://www.sbml.org/sbml/symbols/time\"> time </csymbol/>         |\n"
		"  | inf, infinity   | Mathematical constant \"infinity\"              | <infinity/>                                                                                                  |\n"
		"  | nan, notanumber | Mathematical concept \"not a number\"           | <notanumber/>                                                                                                |\n"
		"  +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+\n"
		"\n"
		"Again, as mentioned above, whether the string \"avogadro\" is parsed\n"
		"as an AST node of type AST_NAME_AVOGADRO or AST_NAME is configurable;\n"
		"use the version of the parser function called\n"
		"parseL3FormulaWithSettings().  This Avogadro-related functionality is\n"
		"provided because SBML Level 2 models may not use AST_NAME_AVOGADRO AST\n"
		"nodes.\n"
		"\n"
		"For more details about the parser, please see the definition of\n"
		"L3ParserSettings and parseL3Formula().\n"
		"\n"
		"See also parseL3Formula(), parseL3FormulaWithSettings(),\n"
		"formulaToL3StringWithSettings(), L3ParserSettings.\n"
		"\n"
		""},
	 { "getLastParseL3Error", _wrap_getLastParseL3Error, METH_NOARGS, "\n"
		"getLastParseL3Error() -> char *\n"
		"\n"
		"Returns the last error reported by the 'L3' mathematical formula\n"
		"parser.\n"
		"\n"
		"If the functions parseL3Formula(), parseL3FormulaWithSettings(), or\n"
		"parseL3FormulaWithModel() return 'None,' an error is set internally.\n"
		"This function allows callers to retrieve information about the error.\n"
		"\n"
		"Returns a string describing the error that occurred.  This will\n"
		"contain the input string the parser was trying to parse, the character\n"
		"it had parsed when it encountered the error, and a description of the\n"
		"error.\n"
		"\n"
		"See also parseL3Formula(), parseL3FormulaWithSettings(),\n"
		"parseL3FormulaWithModel(), getDefaultL3ParserSettings().\n"
		"\n"
		""},
	 { "SBML_deleteL3Parser", _wrap_SBML_deleteL3Parser, METH_NOARGS, "\n"
		"SBML_deleteL3Parser()\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "new_L3ParserSettings", _wrap_new_L3ParserSettings, METH_VARARGS, "\n"
		"L3ParserSettings()\n"
		"L3ParserSettings(Model model, ParseLogType_t parselog, bool collapseminus, bool parseunits, bool avocsymbol, bool caseSensitive=False, SBMLNamespaces sbmlns=None, bool moduloL3v2=False, bool l3v2functions=False)\n"
		"new_L3ParserSettings(L3ParserSettings source) -> L3ParserSettings\n"
		"\n"
		"This method has multiple variants; they differ in the arguments  they\n"
		"accept.  Each variant is described separately below.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    L3ParserSettings()\n"
		"\n"
		"Creates a new L3ParserSettings object with default values.\n"
		"\n"
		"This is the default constructor for the L3ParserSettings object.  It\n"
		"sets the stored Model object to 'None' and sets the following field\n"
		"values in the L3ParserSettings object:\n"
		"\n"
		"* parseunits ('parse units') is set to L3P_PARSE_UNITS.\n"
		"\n"
		"* collapseminus ('collapse minus') is set to\n"
		"L3P_EXPAND_UNARY_MINUS.\n"
		"\n"
		"* parselog ('parse log') is set to L3P_PARSE_LOG_AS_LOG10.\n"
		"\n"
		"* avocsymbol ('Avogadro csymbol') is set to\n"
		"L3P_AVOGADRO_IS_CSYMBOL.\n"
		"\n"
		"* caseSensitive ('case sensitive') is set to\n"
		"L3P_COMPARE_BUILTINS_CASE_INSENSITIVE.\n"
		"\n"
		"* moduloL3v2 ('modulo l3v2') is set to L3P_MODULO_IS_PIECEWISE.\n"
		"\n"
		"* sbmlns ('SBML namespaces') is set to 'None' (which indicates\n"
		"that no syntax extensions due to SBML Level 3 packages will be assumed\n"
		"---the formula parser will only understand the core syntax described\n"
		"in the documentation for parseL3Formula()).\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    L3ParserSettings(L3ParserSettings source)\n"
		"\n"
		"Copy constructor.\n"
		"\n"
		"Parameter 'source' is the instance to copy.\n"
		"\n"
		"______________________________________________________________________\n"
		"Method variant with the following signature:\n"
		"\n"
		"    L3ParserSettings(Model model, ParseLogType_t parselog, bool\n"
		"collapseminus, bool parseunits, bool avocsymbol, bool caseSensitive =\n"
		"false, SBMLNamespaces sbmlns = None, bool moduloL3v2 = false, bool\n"
		"l3v2functions = false)\n"
		"\n"
		"Creates a new L3ParserSettings object with specific values for all\n"
		"possible settings.\n"
		"\n"
		"Parameter 'model' is a Model object to be used for disambiguating\n"
		"identifiers encountered by parseL3FormulaWithSettings() in\n"
		"mathematical formulas.\n"
		"\n"
		"Parameter 'parselog' is ('parse log') a flag that controls how the\n"
		"parser will handle the symbol 'log' in mathematical formulas. The\n"
		"function 'log' with a single argument (\"log(x)\") can be parsed as\n"
		"log10(x), ln(x), or treated as an error, as desired, by using the\n"
		"parameter values L3P_PARSE_LOG_AS_LOG10, L3P_PARSE_LOG_AS_LN, or\n"
		"L3P_PARSE_LOG_AS_ERROR, respectively.\n"
		"\n"
		"Parameter 'collapseminus' is ('collapse minus') a flag that controls\n"
		"how the parser will handle minus signs in formulas.  Unary minus signs\n"
		"can be collapsed or preserved; that is, sequential pairs of unary\n"
		"minuses (e.g., \"- -3\") can be removed from the input entirely and\n"
		"single unary minuses can be incorporated into the number node, or all\n"
		"minuses can be preserved in the AST node structure. The possible\n"
		"values of this field are L3P_COLLAPSE_UNARY_MINUS (to collapse unary\n"
		"minuses) and L3P_EXPAND_UNARY_MINUS (to expand unary minuses).\n"
		"\n"
		"Parameter 'parseunits' is ('parse units') a flag that controls how the\n"
		"parser will handle apparent references to units of measurement\n"
		"associated with raw numbers in a formula.  If set to the value\n"
		"L3P_PARSE_UNITS, units are parsed; if set to the value L3P_NO_UNITS,\n"
		"units are not parsed.\n"
		"\n"
		"Parameter 'avocsymbol' is ('Avogadro csymbol') a flag that controls\n"
		"how the parser will handle the appearance of the symbol 'avogadro' in\n"
		"a formula.  If set to the value L3P_AVOGADRO_IS_CSYMBOL, the symbol is\n"
		"interpreted as the SBML/MathML csymbol 'avogadro;' if set to the value\n"
		"L3P_AVOGADRO_IS_NAME, the symbol is interpreted as a plain symbol\n"
		"name.\n"
		"\n"
		"Parameter 'caseSensitive' is ('case sensitive') a flag that controls\n"
		"how the cases of alphabetical characters are treated when symbols are\n"
		"compared. If the flag is set to the value\n"
		"L3P_COMPARE_BUILTINS_CASE_INSENSITIVE, symbols are compared in a case-\n"
		"insensitive manner, which means that mathematical functions such as\n"
		"''sin'' will be matched no matter what their case is: ''Sin','\n"
		"''SIN',' etc.  If the flag is set to the value\n"
		"L3P_COMPARE_BUILTINS_CASE_SENSITIVE, symbols are interpreted in a\n"
		"case-sensitive manner.\n"
		"\n"
		"Parameter 'sbmlns' is ('SBML namespaces') an SBML namespaces object.\n"
		"The namespaces identify the SBML Level 3 packages that can extend the\n"
		"syntax understood by the formula parser.  When non-'None,' the parser\n"
		"will interpret additional syntax defined by the packages; for example,\n"
		"it may understand vector/array extensions introduced by the SBML Level\n"
		"3 Arrays package.\n"
		"\n"
		"Parameter 'moduloL3v2' is ('modulo L3v2') a flag that controls how the\n"
		"parser will handle the % ('modulo') symbol in formulas.  By default,\n"
		"the parser will convert 'a % b' to a piecewise function that properly\n"
		"calculates the remainder of a with respect to be, but the parser can\n"
		"also be set to produce the MathML 'rem' function, should the target of\n"
		"the produced ASTNode be an SBML Level 3 Version 2  document, where the\n"
		"'rem' function is legal. The possible values of this field are\n"
		"L3P_MODULO_IS_PIECEWISE (to parse % as a piecewise function) and\n"
		"L3P_MODULO_IS_REM (to parse % as 'rem).'\n"
		"\n"
		"Parameter 'l3v2functions' is ('parse L3v2 functions directly') is a\n"
		"Boolean flag that controls how to translate certain mathematical\n"
		"functions added in SBML Level 3 Version 2 Core.  The parser can either\n"
		"turn them into specific AST node types, or turn them all into\n"
		"AST_FUNCTION with the name set to the function name in question.\n"
		"\n"
		"</dl><dl class=\"docnote\"><dt>Documentation note:</dt><dd> The native\n"
		"C++ implementation of this method defines a default argument value. In\n"
		"the documentation generated for different libSBML language bindings,\n"
		"you may or may not see corresponding arguments in the method\n"
		"declarations. For example, in Java and C#, a default argument is\n"
		"handled by declaring two separate methods, with one of them having the\n"
		"argument and the other one lacking the argument. However, the libSBML\n"
		"documentation will be identical for both methods. Consequently, if you\n"
		"are reading this and do not see an argument even though one is\n"
		"described, please look for descriptions of other variants of this\n"
		"method near where this one appears in the documentation. </dd></dl>\n"
		"\n"
		"See also getModel(), setModel(), unsetModel(), getParseLog(),\n"
		"setParseLog(), getParseUnits(), setParseUnits(),\n"
		"getParseCollapseMinus(), setParseCollapseMinus(),\n"
		"getParseAvogadroCsymbol(), setParseAvogadroCsymbol(),\n"
		"getParseModuloL3v2(), setParseModuloL3v2(), getParseL3v2Functions(),\n"
		"setParseL3v2Functions().\n"
		"\n"
		"Note: Owing to the way that language interfaces are created in\n"
		"libSBML, this documentation may show methods that define default\n"
		"values for parameters with text that has the form parameter = value.\n"
		"This is not to be intepreted as a Python keyword argument; the use of\n"
		"a parameter name followed by an equals sign followed by a value is\n"
		"only meant to indicate a default value if the argument is not provided\n"
		"at all.  It is not a keyword in the Python sense.\n"
		"\n"
		""},
	 { "delete_L3ParserSettings", _wrap_delete_L3ParserSettings, METH_O, "delete_L3ParserSettings(L3ParserSettings self)"},
	 { "L3ParserSettings_setModel", _wrap_L3ParserSettings_setModel, METH_VARARGS, "\n"
		"L3ParserSettings_setModel(L3ParserSettings self, Model model)\n"
		"\n"
		"Sets the model reference in this L3ParserSettings object.\n"
		"\n"
		"When a Model object is provided, identifiers (values of type 'SId)'\n"
		"from that model are used in preference to pre-defined MathML symbol\n"
		"definitions.  More precisely, the Model entities whose identifiers\n"
		"will shadow identical symbols in the mathematical formula are:\n"
		"Species, Compartment, Parameter, Reaction, and SpeciesReference.  For\n"
		"instance, if the parser is given a Model containing a Species with the\n"
		"identifier \"pi\", and the formula to be parsed is \"3*pi\", the\n"
		"MathML produced will contain the construct <ci> pi </ci> instead of\n"
		"the construct <pi/>.  Similarly, when a Model object is provided,\n"
		"'SId' values of user-defined functions present in the Model will be\n"
		"used preferentially over pre-defined MathML functions.  For example,\n"
		"if the passed-in Model contains a FunctionDefinition with the\n"
		"identifier \"sin\", that function will be used instead of the\n"
		"predefined MathML function <sin/>.\n"
		"\n"
		"Parameter 'model' is a Model object to be used for disambiguating\n"
		"identifiers.\n"
		"\n"
		"WARNING:\n"
		"\n"
		"This does not copy the Model object. This means that modifications\n"
		"made to the Model after invoking this method may affect parsing\n"
		"behavior, because the parser will query the current contents of the\n"
		"model.\n"
		"\n"
		"See also getModel(), unsetModel().\n"
		"\n"
		""},
	 { "L3ParserSettings_getModel", _wrap_L3ParserSettings_getModel, METH_O, "\n"
		"L3ParserSettings_getModel(L3ParserSettings self) -> Model\n"
		"\n"
		"Returns the Model object referenced by this L3ParserSettings object.\n"
		"\n"
		"When a Model object is provided, identifiers (values of type 'SId)'\n"
		"from that model are used in preference to pre-defined MathML symbol\n"
		"definitions.  More precisely, the Model entities whose identifiers\n"
		"will shadow identical symbols in the mathematical formula are:\n"
		"Species, Compartment, Parameter, Reaction, and SpeciesReference.  For\n"
		"instance, if the parser is given a Model containing a Species with the\n"
		"identifier \"pi\", and the formula to be parsed is \"3*pi\", the\n"
		"MathML produced will contain the construct <ci> pi </ci> instead of\n"
		"the construct <pi/>.  Similarly, when a Model object is provided,\n"
		"'SId' values of user-defined functions present in the Model will be\n"
		"used preferentially over pre-defined MathML functions.  For example,\n"
		"if the passed-in Model contains a FunctionDefinition with the\n"
		"identifier \"sin\", that function will be used instead of the\n"
		"predefined MathML function <sin/>.\n"
		"\n"
		"See also setModel(), unsetModel().\n"
		"\n"
		""},
	 { "L3ParserSettings_unsetModel", _wrap_L3ParserSettings_unsetModel, METH_O, "\n"
		"L3ParserSettings_unsetModel(L3ParserSettings self)\n"
		"\n"
		"Unsets the Model reference in this L3ParserSettings object.\n"
		"\n"
		"The effect of calling this method is to set the stored model value to\n"
		"'None.'\n"
		"\n"
		"See also setModel(), getModel().\n"
		"\n"
		""},
	 { "L3ParserSettings_setParseLog", _wrap_L3ParserSettings_setParseLog, METH_VARARGS, "\n"
		"L3ParserSettings_setParseLog(L3ParserSettings self, ParseLogType_t type)\n"
		"\n"
		"Sets the behavior for handling 'log' in mathematical formulas.\n"
		"\n"
		"The function 'log' with a single argument (\"log(x)\") can be parsed\n"
		"as log10(x), ln(x), or treated as an error. These three behaviors are\n"
		"set, respectively, by using the value L3P_PARSE_LOG_AS_LOG10,\n"
		"L3P_PARSE_LOG_AS_LN, or L3P_PARSE_LOG_AS_ERROR for the 'type'\n"
		"parameter.\n"
		"\n"
		"Parameter 'type' is a constant, one of following three possibilities:\n"
		"\n"
		"* L3P_PARSE_LOG_AS_LOG10\n"
		"\n"
		"* L3P_PARSE_LOG_AS_LN\n"
		"\n"
		"* L3P_PARSE_LOG_AS_ERROR\n"
		"\n"
		"See also getParseLog().\n"
		"\n"
		""},
	 { "L3ParserSettings_getParseLog", _wrap_L3ParserSettings_getParseLog, METH_O, "\n"
		"L3ParserSettings_getParseLog(L3ParserSettings self) -> ParseLogType_t\n"
		"\n"
		"Indicates the current behavior set for handling the function 'log'\n"
		"with one argument.\n"
		"\n"
		"The function 'log' with a single argument (\"log(x)\") can be parsed\n"
		"as log10(x), ln(x), or treated as an error, as desired.  These three\n"
		"possible behaviors are indicated, respectively, by the values\n"
		"L3P_PARSE_LOG_AS_LOG10, L3P_PARSE_LOG_AS_LN, and\n"
		"L3P_PARSE_LOG_AS_ERROR.\n"
		"\n"
		"Returns One of following three constants:\n"
		"\n"
		"* L3P_PARSE_LOG_AS_LOG10\n"
		"\n"
		"* L3P_PARSE_LOG_AS_LN\n"
		"\n"
		"* L3P_PARSE_LOG_AS_ERROR\n"
		"\n"
		"See also setParseLog().\n"
		"\n"
		""},
	 { "L3ParserSettings_setParseCollapseMinus", _wrap_L3ParserSettings_setParseCollapseMinus, METH_VARARGS, "\n"
		"L3ParserSettings_setParseCollapseMinus(L3ParserSettings self, bool collapseminus)\n"
		"\n"
		"Sets the behavior for handling unary minuses appearing in mathematical\n"
		"formulas.\n"
		"\n"
		"This setting affects two behaviors.  First, pairs of multiple unary\n"
		"minuses in a row (e.g., \"- -3\") can be collapsed and ignored in the\n"
		"input, or the multiple minuses can be preserved in the AST node tree\n"
		"that is generated by the parser.  Second, minus signs in front of\n"
		"numbers can be collapsed into the number node itself; for example, a\n"
		"\"- 4.1\" can be turned into a single ASTNode of type AST_REAL with a\n"
		"value of -4.1, or it can be turned into a node of type AST_MINUS\n"
		"having a child node of type AST_REAL.\n"
		"\n"
		"This method lets you tell the parser which behavior to use---either\n"
		"collapse minuses or always preserve them.  The two possibilities are\n"
		"represented using the following constants:\n"
		"\n"
		"* L3P_COLLAPSE_UNARY_MINUS (value = 'True):' collapse unary\n"
		"minuses where possible.\n"
		"\n"
		"* L3P_EXPAND_UNARY_MINUS (value = 'False):' do not collapse unary\n"
		"minuses, and instead translate each one into an AST node of type\n"
		"AST_MINUS. Parameter 'collapseminus' is a boolean value (one of the\n"
		"constants L3P_COLLAPSE_UNARY_MINUS or L3P_EXPAND_UNARY_MINUS)\n"
		"indicating how unary minus signs in the input should be handled.\n"
		"\n"
		"See also getParseCollapseMinus().\n"
		"\n"
		""},
	 { "L3ParserSettings_getParseCollapseMinus", _wrap_L3ParserSettings_getParseCollapseMinus, METH_O, "\n"
		"L3ParserSettings_getParseCollapseMinus(L3ParserSettings self) -> bool\n"
		"\n"
		"Indicates the current behavior set for handling multiple unary minuses\n"
		"in formulas.\n"
		"\n"
		"This setting affects two behaviors.  First, pairs of multiple unary\n"
		"minuses in a row (e.g., \"- -3\") can be collapsed and ignored in the\n"
		"input, or the multiple minuses can be preserved in the AST node tree\n"
		"that is generated by the parser.  Second, minus signs in front of\n"
		"numbers can be collapsed into the number node itself; for example, a\n"
		"\"- 4.1\" can be turned into a single ASTNode of type AST_REAL with a\n"
		"value of -4.1, or it can be turned into a node of type AST_MINUS\n"
		"having a child node of type AST_REAL.\n"
		"\n"
		"Returns A boolean indicating the behavior currently set.  The possible\n"
		"values are as follows:\n"
		"\n"
		"* L3P_COLLAPSE_UNARY_MINUS (value = 'True):' collapse unary minuses\n"
		"where possible.\n"
		"\n"
		"* L3P_EXPAND_UNARY_MINUS (value = 'False):' do not collapse unary\n"
		"minuses, and instead translate each one into an AST node of type\n"
		"AST_MINUS. See also setParseCollapseMinus().\n"
		"\n"
		""},
	 { "L3ParserSettings_setParseUnits", _wrap_L3ParserSettings_setParseUnits, METH_VARARGS, "\n"
		"L3ParserSettings_setParseUnits(L3ParserSettings self, bool units)\n"
		"\n"
		"Sets the parser's behavior in handling units associated with numbers\n"
		"in a mathematical formula.\n"
		"\n"
		"In SBML Level 2, there is no means of associating a unit of\n"
		"measurement with a pure number in a formula, while SBML Level 3 does\n"
		"define a syntax for this.  In Level 3, MathML <cn> elements can have\n"
		"an attribute named 'units' placed in the SBML namespace, which can be\n"
		"used to indicate the units to be associated with the number.  The\n"
		"text-string infix formula parser allows units to be placed after raw\n"
		"numbers; they are interpreted as unit identifiers for units defined by\n"
		"the SBML specification or in the containing Model object. Some\n"
		"examples include: \"4 mL\", \"2.01 Hz\", \"3.1e-6 M\", and \"(5/8)\n"
		"inches\".  To produce a valid SBML model, there must either exist a\n"
		"UnitDefinition corresponding to the identifier of the unit, or the\n"
		"unit must be defined in Table 2 of the SBML Level 3 specification.\n"
		"\n"
		"This method sets the formula parser's behavior with respect to units.\n"
		"\n"
		"Parameter 'units' is a boolean indicating whether to parse units.  The\n"
		"possible values are as follows:\n"
		"\n"
		"* L3P_PARSE_UNITS (value = 'True):' parse units in the text-string\n"
		"formula.\n"
		"\n"
		"* L3P_NO_UNITS (value = 'False):' treat units in the text-string\n"
		"formula as errors. See also getParseUnits().\n"
		"\n"
		""},
	 { "L3ParserSettings_getParseUnits", _wrap_L3ParserSettings_getParseUnits, METH_O, "\n"
		"L3ParserSettings_getParseUnits(L3ParserSettings self) -> bool\n"
		"\n"
		"Indicates the current behavior set for handling units in text-string\n"
		"mathematical formulas.\n"
		"\n"
		"In SBML Level 2, there is no means of associating a unit of\n"
		"measurement with a pure number in a formula, while SBML Level 3 does\n"
		"define a syntax for this.  In Level 3, MathML <cn> elements can have\n"
		"an attribute named 'units' placed in the SBML namespace, which can be\n"
		"used to indicate the units to be associated with the number.  The\n"
		"text-string infix formula parser allows units to be placed after raw\n"
		"numbers; they are interpreted as unit identifiers for units defined by\n"
		"the SBML specification or in the containing Model object. Some\n"
		"examples include: \"4 mL\", \"2.01 Hz\", \"3.1e-6 M\", and \"(5/8)\n"
		"inches\".  To produce a valid SBML model, there must either exist a\n"
		"UnitDefinition corresponding to the identifier of the unit, or the\n"
		"unit must be defined in Table 2 of the SBML Level 3 specification.\n"
		"\n"
		"Since SBML Level 2 does not have the ability to associate units with\n"
		"pure numbers, the value should be expected to be 'False'\n"
		"(L3P_NO_UNITS) when parsing text-string formulas intended for use in\n"
		"SBML Level 2 documents.\n"
		"\n"
		"Returns A boolean indicating whether to parse units.  The possible\n"
		"values are as follows:\n"
		"\n"
		"* L3P_PARSE_UNITS (value = 'True):' parse units in the text-string\n"
		"formula.\n"
		"\n"
		"* L3P_NO_UNITS (value = 'False):' treat units in the text-string\n"
		"formula as errors. See also setParseUnits().\n"
		"\n"
		""},
	 { "L3ParserSettings_setParseAvogadroCsymbol", _wrap_L3ParserSettings_setParseAvogadroCsymbol, METH_VARARGS, "\n"
		"L3ParserSettings_setParseAvogadroCsymbol(L3ParserSettings self, bool l2only)\n"
		"\n"
		"Sets the parser's behavior in handling the symbol 'avogadro' in\n"
		"mathematical formulas.\n"
		"\n"
		"SBML Level 3 defines a symbol for representing the value of\n"
		"Avogadro's constant, but it is not defined in SBML Level 2.  As a\n"
		"result, the text-string formula parser must behave differently\n"
		"depending on which SBML Level is being targeted.  For Level 3\n"
		"documents, it can interpret instances of 'avogadro' in the input as a\n"
		"reference to the MathML csymbol for Avogadro's constant defined in the\n"
		"SBML Level 3 specification.  For Level 2, it must treat 'avogadro' as\n"
		"just another plain symbol.\n"
		"\n"
		"This method allows callers to set the avogadro-handling behavior in\n"
		"this L3ParserSettings object.  The possible values of 'l2only' are as\n"
		"follows:\n"
		"\n"
		"* L3P_AVOGADRO_IS_CSYMBOL (value = 'True):' tells the parser to\n"
		"translate the string 'avogadro' (in any capitalization) into an AST\n"
		"node of type AST_NAME_AVOGADRO.\n"
		"\n"
		"* L3P_AVOGADRO_IS_NAME (value = 'False):' tells the parser to\n"
		"translate the string 'avogadro' into an AST of type AST_NAME. Since\n"
		"SBML Level 2 does not define a symbol for Avogadro's constant, the\n"
		"value should be set to L3P_AVOGADRO_IS_NAME when parsing text-string\n"
		"formulas intended for use in SBML Level 2 documents.\n"
		"\n"
		"Parameter 'l2only' is a boolean value indicating how the string\n"
		"'avogadro' should be treated when encountered in a formula.  This will\n"
		"be one of the values L3P_AVOGADRO_IS_CSYMBOL or L3P_AVOGADRO_IS_NAME.\n"
		"\n"
		"See also getParseAvogadroCsymbol().\n"
		"\n"
		""},
	 { "L3ParserSettings_getParseAvogadroCsymbol", _wrap_L3ParserSettings_getParseAvogadroCsymbol, METH_O, "\n"
		"L3ParserSettings_getParseAvogadroCsymbol(L3ParserSettings self) -> bool\n"
		"\n"
		"Indicates the current behavior set for handling 'avogadro' for SBML\n"
		"Level 3.\n"
		"\n"
		"SBML Level 3 defines a symbol for representing the value of\n"
		"Avogadro's constant, but it is not defined in SBML Level 2.  As a\n"
		"result, the text-string formula parser must behave differently\n"
		"depending on which SBML Level is being targeted.  For Level 3\n"
		"documents, it can interpret instances of 'avogadro' in the input as a\n"
		"reference to the MathML csymbol for Avogadro's constant defined in the\n"
		"SBML Level 3 specification.  For Level 2, it must treat 'avogadro' as\n"
		"just another plain symbol.\n"
		"\n"
		"This method returns the current setting of the avogadro-handling\n"
		"behavior in this L3ParserSettings object. The possible values are as\n"
		"follows:\n"
		"\n"
		"* L3P_AVOGADRO_IS_CSYMBOL (value = 'True):' tells the parser to\n"
		"translate the string 'avogadro' (in any capitalization) into an AST\n"
		"node of type AST_NAME_AVOGADRO.\n"
		"\n"
		"* L3P_AVOGADRO_IS_NAME (value = 'False):' tells the parser to\n"
		"translate the string 'avogadro' into an AST of type AST_NAME. Returns\n"
		"A boolean indicating which mode is currently set; one of\n"
		"L3P_AVOGADRO_IS_CSYMBOL or L3P_AVOGADRO_IS_NAME.\n"
		"\n"
		"See also setParseAvogadroCsymbol().\n"
		"\n"
		""},
	 { "L3ParserSettings_setComparisonCaseSensitivity", _wrap_L3ParserSettings_setComparisonCaseSensitivity, METH_VARARGS, "\n"
		"L3ParserSettings_setComparisonCaseSensitivity(L3ParserSettings self, bool strcmp)\n"
		"\n"
		"Sets the parser's behavior with respect to case sensitivity for\n"
		"recognizing predefined symbols.\n"
		"\n"
		"By default (which is the value\n"
		"L3P_COMPARE_BUILTINS_CASE_INSENSITIVE), the parser compares symbols in\n"
		"a case insensitive manner for built-in functions such as ''sin'' and\n"
		"''piecewise',' and for constants such as ''True'' and ''avogadro'.'\n"
		"Setting this option to L3P_COMPARE_BUILTINS_CASE_SENSITIVE causes the\n"
		"parser to become case sensitive.  In that mode, for example, the\n"
		"symbols ''sin'' and ''True'' will match the built-in values, but the\n"
		"symbols ''SIN',' ''Sin',' ''True',' ''TRUE',' and so on, will not.\n"
		"\n"
		"Parameter 'strcmp' is a boolean indicating whether to be case\n"
		"sensitive (if 'True)' or be case insensitive (if 'False).'\n"
		"\n"
		"See also getComparisonCaseSensitivity().\n"
		"\n"
		""},
	 { "L3ParserSettings_getComparisonCaseSensitivity", _wrap_L3ParserSettings_getComparisonCaseSensitivity, METH_O, "\n"
		"L3ParserSettings_getComparisonCaseSensitivity(L3ParserSettings self) -> bool\n"
		"\n"
		"Returns 'True' if the parser is configured to match built-in symbols\n"
		"in a case-insensitive way.\n"
		"\n"
		"By default (which is the value\n"
		"L3P_COMPARE_BUILTINS_CASE_INSENSITIVE), the parser compares symbols in\n"
		"a case insensitive manner for built-in functions such as ''sin'' and\n"
		"''piecewise',' and for constants such as ''True'' and ''avogadro'.'\n"
		"Setting this option to L3P_COMPARE_BUILTINS_CASE_SENSITIVE causes the\n"
		"parser to become case sensitive.  In that mode, for example, the\n"
		"symbols ''sin'' and ''True'' will match the built-in values, but the\n"
		"symbols ''SIN',' ''Sin',' ''True',' ''TRUE',' and so on, will not.\n"
		"\n"
		"Returns 'True' if matches are done in a case-sensitive manner, and\n"
		"'False' if the parser will recognize built-in functions and constants\n"
		"regardless of case,.\n"
		"\n"
		"See also setComparisonCaseSensitivity().\n"
		"\n"
		""},
	 { "L3ParserSettings_setParseModuloL3v2", _wrap_L3ParserSettings_setParseModuloL3v2, METH_VARARGS, "\n"
		"L3ParserSettings_setParseModuloL3v2(L3ParserSettings self, bool modulol3v2)\n"
		"\n"
		"Sets the behavior for handling the % symbol in mathematical formulas.\n"
		"\n"
		"This setting affects whether the % symbol (modulo) is parsed as a\n"
		"piecewise equation that returns the modulo value of the entries on\n"
		"either side of the symbol, or whether it is parsed as the MathML\n"
		"'rem' function, which was allowed in SBML Level 3 Version 2, but not\n"
		"in previous level/versions.  The latter is more succinct, but  might\n"
		"not be legal SBML for the desired target SBML document.\n"
		"\n"
		"This method lets you tell the parser which behavior to use---either\n"
		"parse % as the 'rem' function or as a piecewise function with the same\n"
		"interpretation.  The two possibilities are represented using the\n"
		"following constants:\n"
		"\n"
		"* L3P_MODULO_IS_REM (value = 'True):' use the 'rem' MathML\n"
		"function (AST_FUNCTION_REM).\n"
		"\n"
		"* L3P_MODULO_IS_PIECEWISE (value = 'False):' use  a piecewise\n"
		"function (AST_FUNCTION_PIECEWISE) to encode the modulo rule\n"
		"explicitly. Parameter 'modulol3v2' is a boolean value (one of the\n"
		"constants L3P_MODULO_IS_PIECEWISE or L3P_MODULO_IS_REM) indicating how\n"
		"the % symbol in the input should be handled.\n"
		"\n"
		"See also getParseModuloL3v2().\n"
		"\n"
		""},
	 { "L3ParserSettings_getParseModuloL3v2", _wrap_L3ParserSettings_getParseModuloL3v2, METH_O, "\n"
		"L3ParserSettings_getParseModuloL3v2(L3ParserSettings self) -> bool\n"
		"\n"
		"Indicates the current behavior set for handling the % symbol in\n"
		"mathematical formulas.\n"
		"\n"
		"This setting affects whether the % symbol (modulo) is parsed as a\n"
		"piecewise equation that returns the modulo value of the entries on\n"
		"either side of the symbol, or whether it is parsed as the MathML\n"
		"'rem' function, which was allowed in SBML Level 3 Version 2, but not\n"
		"in previous level/versions.  The latter is more succinct, but  might\n"
		"not be legal SBML for the desired target SBML document.\n"
		"\n"
		"Returns A boolean indicating the behavior currently set.  The possible\n"
		"values are as follows:\n"
		"\n"
		"* L3P_MODULO_IS_REM (value = 'True):' use the 'rem' MathML function\n"
		"(AST_FUNCTION_REM).\n"
		"\n"
		"* L3P_MODULO_IS_PIECEWISE (value = 'False):' use  a piecewise\n"
		"function (AST_FUNCTION_PIECEWISE) to encode the modulo rule\n"
		"explicitly. See also setParseModuloL3v2().\n"
		"\n"
		""},
	 { "L3ParserSettings_setParseL3v2Functions", _wrap_L3ParserSettings_setParseL3v2Functions, METH_VARARGS, "\n"
		"L3ParserSettings_setParseL3v2Functions(L3ParserSettings self, bool l3v2functions)\n"
		"\n"
		"Sets the behavior for handling functions added in SBML L3v2\n"
		"\n"
		"This setting affects whether the names of functions added in SBML\n"
		"Level 3 Version 2 are parsed as those added MathML functions, or\n"
		"whether they are added as generic functions with those names (to be\n"
		"used in SBML as function definitions).\n"
		"\n"
		"This method lets you tell the parser which behavior to use---either to\n"
		"parse the functions added in L3v2 as their built-in counterparts, or\n"
		"as generic functions with that name (to be defined by SBML as function\n"
		"definitions).  The two possibilities are represented using the\n"
		"following constants:\n"
		"\n"
		"* L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY (value = 'True):' parse the\n"
		"strings rateOf, implies, max, min, quotient, and rem as\n"
		"AST_FUNCTION_RATE_OF, AST_LOGICAL_IMPLIES, AST_FUNCTION_MAX,\n"
		"AST_FUNCTION_MIN, AST_FUNCTION_QUOTIENT, and AST_FUNCTION_REM,\n"
		"respectively.\n"
		"\n"
		"* L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC (value = 'False):' parse the\n"
		"strings rateOf, implies, max, min, quotient, and rem all as\n"
		"AST_FUNCTION with the appropriate name set. Parameter 'l3v2functions'\n"
		"is a boolean value (one of the constants\n"
		"L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY or\n"
		"L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC) indicating how to interpret those\n"
		"function names.\n"
		"\n"
		"See also getParseL3v2Functions().\n"
		"\n"
		""},
	 { "L3ParserSettings_getParseL3v2Functions", _wrap_L3ParserSettings_getParseL3v2Functions, METH_O, "\n"
		"L3ParserSettings_getParseL3v2Functions(L3ParserSettings self) -> bool\n"
		"\n"
		"Indicates the current behavior set for handling whether to parse the\n"
		"functions added in L3v2 as that MathML or not.\n"
		"\n"
		"This setting affects whether the names of functions added in SBML\n"
		"Level 3 Version 2 are parsed as those added MathML functions, or\n"
		"whether they are added as generic functions with those names (to be\n"
		"used in SBML as function definitions).\n"
		"\n"
		"Returns A boolean indicating the behavior currently set.  The possible\n"
		"values are as follows:\n"
		"\n"
		"* L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY (value = 'True):' parse the\n"
		"strings rateOf, implies, max, min, quotient, and rem as\n"
		"AST_FUNCTION_RATE_OF, AST_LOGICAL_IMPLIES, AST_FUNCTION_MAX,\n"
		"AST_FUNCTION_MIN, AST_FUNCTION_QUOTIENT, and AST_FUNCTION_REM,\n"
		"respectively.\n"
		"\n"
		"* L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC (value = 'False):' parse the\n"
		"strings rateOf, implies, max, min, quotient, and rem all as\n"
		"AST_FUNCTION with the appropriate name set. See also\n"
		"setParseL3v2Functions().\n"
		"\n"
		""},
	 { "L3ParserSettings_setParsePackageMath", _wrap_L3ParserSettings_setParsePackageMath, METH_VARARGS, "\n"
		"L3ParserSettings_setParsePackageMath(L3ParserSettings self, ExtendedMathType_t package, bool parsepackage)\n"
		"\n"
		"Sets the behavior for handling functions added in SBML packages\n"
		"\n"
		"This setting affects whether the math added in a given SBML Level 3\n"
		"package are parsed as those added MathML elements,  or whether they\n"
		"are added as generic functions or variables with those names.\n"
		"\n"
		"This method lets you tell the parser which behavior to use---either to\n"
		"parse the functions added in a given package as their built-in\n"
		"counterparts, or as generic functions with that name (to be defined by\n"
		"SBML as function definitions).  The two possibilities are represented\n"
		"using the following constants:\n"
		"\n"
		"* L3P_PARSE_PACKAGE_MATH_DIRECTLY (value = 'True):' parse any\n"
		"string defined in a given SBML L3 package as its corresponding\n"
		"ASTType_t.\n"
		"\n"
		"* L3P_PARSE_PACKAGE_MATH_AS_GENERIC (value = 'False):'  parse any\n"
		"string that would have been defined in the given SBML L3 package as\n"
		"AST_FUNCTION or AST_NAME  with the appropriate name set. Parameter\n"
		"'package' is an ExtendedMathType_t indicating the extended math\n"
		"package to be queried. Parameter 'parsepackage' is a boolean value\n"
		"(one of the constants L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY or\n"
		"L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC) indicating how to interpret those\n"
		"function names.\n"
		"\n"
		"See also getParsePackageMath().\n"
		"\n"
		""},
	 { "L3ParserSettings_getParsePackageMath", _wrap_L3ParserSettings_getParsePackageMath, METH_VARARGS, "\n"
		"L3ParserSettings_getParsePackageMath(L3ParserSettings self, ExtendedMathType_t package) -> bool\n"
		"\n"
		"Indicates the current behavior set for handling whether to parse the\n"
		"functions added in the given package as that MathML or not.\n"
		"\n"
		"This setting affects whether the math added in a given SBML Level 3\n"
		"package are parsed as those added MathML elements,  or whether they\n"
		"are added as generic functions or variables with those names.\n"
		"\n"
		"Parameter 'package' is an ExtendedMathType_t indicating the extended\n"
		"math package to be set.\n"
		"\n"
		"Returns A boolean indicating the behavior currently set.  The possible\n"
		"values are as follows:\n"
		"\n"
		"* L3P_PARSE_PACKAGE_MATH_DIRECTLY (value = 'True):' parse any  string\n"
		"defined in a given SBML L3 package as its corresponding ASTType_t.\n"
		"\n"
		"* L3P_PARSE_PACKAGE_MATH_AS_GENERIC (value = 'False):'  parse any\n"
		"string that would have been defined in the given SBML L3 package as\n"
		"AST_FUNCTION or AST_NAME  with the appropriate name set. See also\n"
		"setParsePackageMath().\n"
		"\n"
		""},
	 { "L3ParserSettings_visitPackageInfixSyntax", _wrap_L3ParserSettings_visitPackageInfixSyntax, METH_VARARGS, "\n"
		"L3ParserSettings_visitPackageInfixSyntax(L3ParserSettings self, ASTNode parent, ASTNode node, StringBuffer_t * sb)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "L3ParserSettings_swigregister", L3ParserSettings_swigregister, METH_O, NULL},
	 { "L3ParserSettings_swiginit", L3ParserSettings_swiginit, METH_VARARGS, NULL},
	 { "DefinitionURLRegistry_getInstance", _wrap_DefinitionURLRegistry_getInstance, METH_NOARGS, "\n"
		"DefinitionURLRegistry_getInstance() -> DefinitionURLRegistry\n"
		"\n"
		"Returns the singleton instance for the DefinitionURL registry.\n"
		"\n"
		"Prior to using the registry, callers have to obtain a copy of the\n"
		"registry.  This static method provides the means for doing that.\n"
		"\n"
		"Returns the singleton for the DefinitionURL registry.\n"
		"\n"
		""},
	 { "DefinitionURLRegistry_addDefinitionURL", _wrap_DefinitionURLRegistry_addDefinitionURL, METH_VARARGS, "\n"
		"DefinitionURLRegistry_addDefinitionURL(string url, int type) -> int\n"
		"\n"
		"Adds the given DefinitionURL to the registry of SBML DefinitionURLs.\n"
		"\n"
		"Parameter 'url' is the DefinitionURL to add to the registry. Parameter\n"
		"'type' is the ASTNodeType_t of the URL to add to the registry.\n"
		"\n"
		"Returns integer value indicating success/failure of the function.\n"
		"The possible values returned by this function are:\n"
		"\n"
		"* LIBSBML_OPERATION_SUCCESS\n"
		"\n"
		"* LIBSBML_INVALID_OBJECT\n"
		"\n"
		""},
	 { "DefinitionURLRegistry_getNumDefinitionURLs", _wrap_DefinitionURLRegistry_getNumDefinitionURLs, METH_NOARGS, "\n"
		"DefinitionURLRegistry_getNumDefinitionURLs() -> int\n"
		"\n"
		"Returns the number of DefinitionURLs known by the registry.\n"
		"\n"
		"Returns the number of registered DefinitionURLs.\n"
		"\n"
		"See also getDefinitionURLByIndex().\n"
		"\n"
		""},
	 { "DefinitionURLRegistry_addSBMLDefinitions", _wrap_DefinitionURLRegistry_addSBMLDefinitions, METH_NOARGS, "\n"
		"DefinitionURLRegistry_addSBMLDefinitions()\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "DefinitionURLRegistry_getCoreDefinitionsAdded", _wrap_DefinitionURLRegistry_getCoreDefinitionsAdded, METH_NOARGS, "\n"
		"DefinitionURLRegistry_getCoreDefinitionsAdded() -> bool\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "DefinitionURLRegistry_getType", _wrap_DefinitionURLRegistry_getType, METH_O, "\n"
		"DefinitionURLRegistry_getType(string url) -> int\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "DefinitionURLRegistry_getDefinitionUrlByIndex", _wrap_DefinitionURLRegistry_getDefinitionUrlByIndex, METH_O, "\n"
		"DefinitionURLRegistry_getDefinitionUrlByIndex(int index) -> string\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "DefinitionURLRegistry_clearDefinitions", _wrap_DefinitionURLRegistry_clearDefinitions, METH_NOARGS, "\n"
		"DefinitionURLRegistry_clearDefinitions()\n"
		"\n"
		"\n"
		"\n"
		""},
	 { "delete_DefinitionURLRegistry", _wrap_delete_DefinitionURLRegistry, METH_O, "delete_DefinitionURLRegistry(DefinitionURLRegistry self)"},
	 { "DefinitionURLRegistry_swigregister", DefinitionURLRegistry_swigregister, METH_O, NULL},
	 { "new_MathFilter", _wrap_new_MathFilter, METH_O, "\n"
		"new_MathFilter(PyObject * _self) -> MathFilter\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "delete_MathFilter", _wrap_delete_MathFilter, METH_O, "delete_MathFilter(MathFilter self)"},
	 { "MathFilter_filter", _wrap_MathFilter_filter, METH_VARARGS, "\n"
		"MathFilter_filter(MathFilter self, SBase element) -> bool\n"
		"\n"
		"Predicate to test elements.\n"
		"\n"
		"This is the central predicate of the ElementFilter class.  In\n"
		"subclasses of ElementFilter, callers should implement this method such\n"
		"that it returns 'True' for 'element' arguments that are 'desirable'\n"
		"and 'False' for those that are 'undesirable' in whatever filtering\n"
		"context the ElementFilter subclass is designed to be used.\n"
		"\n"
		"Parameter 'element' is the element to be tested.\n"
		"\n"
		"Returns 'True' if the 'element' is desirable or should be kept,\n"
		"'False' otherwise.\n"
		"\n"
		""},
	 { "disown_MathFilter", _wrap_disown_MathFilter, METH_O, NULL},
	 { "MathFilter_swigregister", MathFilter_swigregister, METH_O, NULL},
	 { "MathFilter_swiginit", MathFilter_swiginit, METH_VARARGS, NULL},
	 { "ASTNodeValues_t_name_set", _wrap_ASTNodeValues_t_name_set, METH_VARARGS, "ASTNodeValues_t_name_set(ASTNodeValues_t self, string name)"},
	 { "ASTNodeValues_t_name_get", _wrap_ASTNodeValues_t_name_get, METH_O, "ASTNodeValues_t_name_get(ASTNodeValues_t self) -> string"},
	 { "ASTNodeValues_t_type_set", _wrap_ASTNodeValues_t_type_set, METH_VARARGS, "ASTNodeValues_t_type_set(ASTNodeValues_t self, ASTNodeType_t type)"},
	 { "ASTNodeValues_t_type_get", _wrap_ASTNodeValues_t_type_get, METH_O, "ASTNodeValues_t_type_get(ASTNodeValues_t self) -> ASTNodeType_t"},
	 { "ASTNodeValues_t_isFunction_set", _wrap_ASTNodeValues_t_isFunction_set, METH_VARARGS, "ASTNodeValues_t_isFunction_set(ASTNodeValues_t self, bool isFunction)"},
	 { "ASTNodeValues_t_isFunction_get", _wrap_ASTNodeValues_t_isFunction_get, METH_O, "ASTNodeValues_t_isFunction_get(ASTNodeValues_t self) -> bool"},
	 { "ASTNodeValues_t_csymbolURL_set", _wrap_ASTNodeValues_t_csymbolURL_set, METH_VARARGS, "ASTNodeValues_t_csymbolURL_set(ASTNodeValues_t self, string csymbolURL)"},
	 { "ASTNodeValues_t_csymbolURL_get", _wrap_ASTNodeValues_t_csymbolURL_get, METH_O, "ASTNodeValues_t_csymbolURL_get(ASTNodeValues_t self) -> string"},
	 { "ASTNodeValues_t_allowedChildrenType_set", _wrap_ASTNodeValues_t_allowedChildrenType_set, METH_VARARGS, "ASTNodeValues_t_allowedChildrenType_set(ASTNodeValues_t self, AllowedChildrenType_t allowedChildrenType)"},
	 { "ASTNodeValues_t_allowedChildrenType_get", _wrap_ASTNodeValues_t_allowedChildrenType_get, METH_O, "ASTNodeValues_t_allowedChildrenType_get(ASTNodeValues_t self) -> AllowedChildrenType_t"},
	 { "ASTNodeValues_t_numAllowedChildren_set", _wrap_ASTNodeValues_t_numAllowedChildren_set, METH_VARARGS, "ASTNodeValues_t_numAllowedChildren_set(ASTNodeValues_t self, std::vector< unsigned int > numAllowedChildren)"},
	 { "ASTNodeValues_t_numAllowedChildren_get", _wrap_ASTNodeValues_t_numAllowedChildren_get, METH_O, "ASTNodeValues_t_numAllowedChildren_get(ASTNodeValues_t self) -> std::vector< unsigned int >"},
	 { "new_ASTNodeValues_t", _wrap_new_ASTNodeValues_t, METH_NOARGS, "new_ASTNodeValues_t() -> ASTNodeValues_t"},
	 { "delete_ASTNodeValues_t", _wrap_delete_ASTNodeValues_t, METH_O, "delete_ASTNodeValues_t(ASTNodeValues_t self)"},
	 { "ASTNodeValues_t_swigregister", ASTNodeValues_t_swigregister, METH_O, NULL},
	 { "ASTNodeValues_t_swiginit", ASTNodeValues_t_swiginit, METH_VARARGS, NULL},
	 { "ASTBasePlugin_getStringFor", _wrap_ASTBasePlugin_getStringFor, METH_VARARGS, "ASTBasePlugin_getStringFor(ASTBasePlugin self, ASTNodeType_t type) -> string"},
	 { "ASTBasePlugin_getConstCharFor", _wrap_ASTBasePlugin_getConstCharFor, METH_VARARGS, "ASTBasePlugin_getConstCharFor(ASTBasePlugin self, ASTNodeType_t type) -> char const *"},
	 { "ASTBasePlugin_getConstCharCsymbolURLFor", _wrap_ASTBasePlugin_getConstCharCsymbolURLFor, METH_VARARGS, "ASTBasePlugin_getConstCharCsymbolURLFor(ASTBasePlugin self, ASTNodeType_t type) -> char const *"},
	 { "ASTBasePlugin_getASTNodeTypeFor", _wrap_ASTBasePlugin_getASTNodeTypeFor, METH_VARARGS, "ASTBasePlugin_getASTNodeTypeFor(ASTBasePlugin self, string symbol) -> ASTNodeType_t"},
	 { "ASTBasePlugin_getASTNodeTypeForCSymbolURL", _wrap_ASTBasePlugin_getASTNodeTypeForCSymbolURL, METH_VARARGS, "ASTBasePlugin_getASTNodeTypeForCSymbolURL(ASTBasePlugin self, string url) -> ASTNodeType_t"},
	 { "ASTBasePlugin_hasCorrectNamespace", _wrap_ASTBasePlugin_hasCorrectNamespace, METH_VARARGS, "ASTBasePlugin_hasCorrectNamespace(ASTBasePlugin self, SBMLNamespaces namespaces) -> bool"},
	 { "ASTBasePlugin_defines", _wrap_ASTBasePlugin_defines, METH_VARARGS, "\n"
		"ASTBasePlugin_defines(ASTBasePlugin self, ASTNodeType_t type) -> bool\n"
		"ASTBasePlugin_defines(ASTBasePlugin self, string name, bool strCmpIsCaseSensitive=False) -> bool\n"
		""},
	 { "ASTBasePlugin_isFunction", _wrap_ASTBasePlugin_isFunction, METH_VARARGS, "ASTBasePlugin_isFunction(ASTBasePlugin self, ASTNodeType_t type) -> bool"},
	 { "ASTBasePlugin_getNumAllowedChildren", _wrap_ASTBasePlugin_getNumAllowedChildren, METH_VARARGS, "ASTBasePlugin_getNumAllowedChildren(ASTBasePlugin self, ASTNodeType_t type) -> std::vector< unsigned int >"},
	 { "ASTBasePlugin_isLogical", _wrap_ASTBasePlugin_isLogical, METH_VARARGS, "ASTBasePlugin_isLogical(ASTBasePlugin self, ASTNodeType_t type) -> bool"},
	 { "ASTBasePlugin_isMathMLNodeTag", _wrap_ASTBasePlugin_isMathMLNodeTag, METH_VARARGS, "\n"
		"ASTBasePlugin_isMathMLNodeTag(ASTBasePlugin self, string node) -> bool\n"
		"ASTBasePlugin_isMathMLNodeTag(ASTBasePlugin self, ASTNodeType_t type) -> bool\n"
		""},
	 { "ASTBasePlugin_getExtendedMathType", _wrap_ASTBasePlugin_getExtendedMathType, METH_O, "ASTBasePlugin_getExtendedMathType(ASTBasePlugin self) -> ExtendedMathType_t"},
	 { "ASTBasePlugin_evaluateASTNode", _wrap_ASTBasePlugin_evaluateASTNode, METH_VARARGS, "ASTBasePlugin_evaluateASTNode(ASTBasePlugin self, ASTNode node, Model m=None) -> double"},
	 { "ASTBasePlugin_getUnitDefinitionFromPackage", _wrap_ASTBasePlugin_getUnitDefinitionFromPackage, METH_VARARGS, "ASTBasePlugin_getUnitDefinitionFromPackage(ASTBasePlugin self, UnitFormulaFormatter * uff, ASTNode node, bool inKL, int reactNo) -> UnitDefinition"},
	 { "ASTBasePlugin_getASTNodeValue", _wrap_ASTBasePlugin_getASTNodeValue, METH_VARARGS, "ASTBasePlugin_getASTNodeValue(ASTBasePlugin self, unsigned int n) -> ASTNodeValues_t"},
	 { "ASTBasePlugin_allowedInFunctionDefinition", _wrap_ASTBasePlugin_allowedInFunctionDefinition, METH_VARARGS, "\n"
		"ASTBasePlugin_allowedInFunctionDefinition(ASTBasePlugin self, ASTNodeType_t type) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "delete_ASTBasePlugin", _wrap_delete_ASTBasePlugin, METH_O, "delete_ASTBasePlugin(ASTBasePlugin self)"},
	 { "ASTBasePlugin_clone", _wrap_ASTBasePlugin_clone, METH_O, "\n"
		"ASTBasePlugin_clone(ASTBasePlugin self) -> ASTBasePlugin\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_getElementNamespace", _wrap_ASTBasePlugin_getElementNamespace, METH_O, "\n"
		"ASTBasePlugin_getElementNamespace(ASTBasePlugin self) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_getPrefix", _wrap_ASTBasePlugin_getPrefix, METH_O, "\n"
		"ASTBasePlugin_getPrefix(ASTBasePlugin self) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_getPackageName", _wrap_ASTBasePlugin_getPackageName, METH_O, "\n"
		"ASTBasePlugin_getPackageName(ASTBasePlugin self) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_setSBMLExtension", _wrap_ASTBasePlugin_setSBMLExtension, METH_VARARGS, "\n"
		"ASTBasePlugin_setSBMLExtension(ASTBasePlugin self, SBMLExtension ext) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_setPrefix", _wrap_ASTBasePlugin_setPrefix, METH_VARARGS, "\n"
		"ASTBasePlugin_setPrefix(ASTBasePlugin self, string prefix) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_connectToParent", _wrap_ASTBasePlugin_connectToParent, METH_VARARGS, "\n"
		"ASTBasePlugin_connectToParent(ASTBasePlugin self, ASTNode astbase)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_enablePackageInternal", _wrap_ASTBasePlugin_enablePackageInternal, METH_VARARGS, "\n"
		"ASTBasePlugin_enablePackageInternal(ASTBasePlugin self, string pkgURI, string pkgPrefix, bool flag)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_stripPackage", _wrap_ASTBasePlugin_stripPackage, METH_VARARGS, "\n"
		"ASTBasePlugin_stripPackage(ASTBasePlugin self, string pkgPrefix, bool flag) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_getURI", _wrap_ASTBasePlugin_getURI, METH_O, "\n"
		"ASTBasePlugin_getURI(ASTBasePlugin self) -> string\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_getParentASTObject", _wrap_ASTBasePlugin_getParentASTObject, METH_VARARGS, "\n"
		"ASTBasePlugin_getParentASTObject(ASTBasePlugin self) -> ASTNode\n"
		"ASTBasePlugin_getParentASTObject(ASTBasePlugin self) -> ASTNode\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_setElementNamespace", _wrap_ASTBasePlugin_setElementNamespace, METH_VARARGS, "\n"
		"ASTBasePlugin_setElementNamespace(ASTBasePlugin self, string uri) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_getLevel", _wrap_ASTBasePlugin_getLevel, METH_O, "\n"
		"ASTBasePlugin_getLevel(ASTBasePlugin self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_getVersion", _wrap_ASTBasePlugin_getVersion, METH_O, "\n"
		"ASTBasePlugin_getVersion(ASTBasePlugin self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_getPackageVersion", _wrap_ASTBasePlugin_getPackageVersion, METH_O, "\n"
		"ASTBasePlugin_getPackageVersion(ASTBasePlugin self) -> unsigned int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_getSBMLNamespaces", _wrap_ASTBasePlugin_getSBMLNamespaces, METH_O, "\n"
		"ASTBasePlugin_getSBMLNamespaces(ASTBasePlugin self) -> SBMLNamespaces\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_renameSIdRefs", _wrap_ASTBasePlugin_renameSIdRefs, METH_VARARGS, "\n"
		"ASTBasePlugin_renameSIdRefs(ASTBasePlugin self, string oldid, string newid)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_renameUnitSIdRefs", _wrap_ASTBasePlugin_renameUnitSIdRefs, METH_VARARGS, "\n"
		"ASTBasePlugin_renameUnitSIdRefs(ASTBasePlugin self, string oldid, string newid)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_replaceIDWithFunction", _wrap_ASTBasePlugin_replaceIDWithFunction, METH_VARARGS, "\n"
		"ASTBasePlugin_replaceIDWithFunction(ASTBasePlugin self, string id, ASTNode function)\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_checkNumArguments", _wrap_ASTBasePlugin_checkNumArguments, METH_VARARGS, "\n"
		"ASTBasePlugin_checkNumArguments(ASTBasePlugin self, ASTNode function, std::stringstream & error) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_getL3PackageInfixPrecedence", _wrap_ASTBasePlugin_getL3PackageInfixPrecedence, METH_O, "\n"
		"ASTBasePlugin_getL3PackageInfixPrecedence(ASTBasePlugin self) -> int\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_hasCorrectNumArguments", _wrap_ASTBasePlugin_hasCorrectNumArguments, METH_VARARGS, "\n"
		"ASTBasePlugin_hasCorrectNumArguments(ASTBasePlugin self, ASTNode function) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_hasPackageOnlyInfixSyntax", _wrap_ASTBasePlugin_hasPackageOnlyInfixSyntax, METH_O, "\n"
		"ASTBasePlugin_hasPackageOnlyInfixSyntax(ASTBasePlugin self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_hasUnambiguousPackageInfixGrammar", _wrap_ASTBasePlugin_hasUnambiguousPackageInfixGrammar, METH_VARARGS, "\n"
		"ASTBasePlugin_hasUnambiguousPackageInfixGrammar(ASTBasePlugin self, ASTNode child) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_isPackageInfixFunction", _wrap_ASTBasePlugin_isPackageInfixFunction, METH_O, "\n"
		"ASTBasePlugin_isPackageInfixFunction(ASTBasePlugin self) -> bool\n"
		"\n"
		"Internal implementation method.\n"
		"\n"
		""},
	 { "ASTBasePlugin_swigregister", ASTBasePlugin_swigregister, METH_O, NULL},
	 { NULL, NULL, 0, NULL }
};

static PyMethodDef SwigMethods_proxydocs[] = {
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_SBMLConstructorExceptionTo_p_std__invalid_argument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::invalid_argument *)  ((SBMLConstructorException *) x));
}
static void *_p_XMLConstructorExceptionTo_p_std__invalid_argument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::invalid_argument *)  ((XMLConstructorException *) x));
}
static void *_p_SBMLExtensionExceptionTo_p_std__invalid_argument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::invalid_argument *)  ((SBMLExtensionException *) x));
}
static void *_p_AlgebraicRuleTo_p_Rule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Rule *)  ((AlgebraicRule *) x));
}
static void *_p_AssignmentRuleTo_p_Rule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Rule *)  ((AssignmentRule *) x));
}
static void *_p_RateRuleTo_p_Rule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Rule *)  ((RateRule *) x));
}
static void *_p_SBMLFunctionDefinitionConverterTo_p_SBMLConverter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLConverter *)  ((SBMLFunctionDefinitionConverter *) x));
}
static void *_p_SBMLIdConverterTo_p_SBMLConverter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLConverter *)  ((SBMLIdConverter *) x));
}
static void *_p_SBMLInferUnitsConverterTo_p_SBMLConverter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLConverter *)  ((SBMLInferUnitsConverter *) x));
}
static void *_p_SBMLInitialAssignmentConverterTo_p_SBMLConverter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLConverter *)  ((SBMLInitialAssignmentConverter *) x));
}
static void *_p_SBMLLevelVersionConverterTo_p_SBMLConverter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLConverter *)  ((SBMLLevelVersionConverter *) x));
}
static void *_p_SBMLLevel1Version1ConverterTo_p_SBMLConverter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLConverter *)  ((SBMLLevel1Version1Converter *) x));
}
static void *_p_SBMLLocalParameterConverterTo_p_SBMLConverter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLConverter *)  ((SBMLLocalParameterConverter *) x));
}
static void *_p_SBMLReactionConverterTo_p_SBMLConverter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLConverter *)  ((SBMLReactionConverter *) x));
}
static void *_p_SBMLRuleConverterTo_p_SBMLConverter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLConverter *)  ((SBMLRuleConverter *) x));
}
static void *_p_SBMLStripPackageConverterTo_p_SBMLConverter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLConverter *)  ((SBMLStripPackageConverter *) x));
}
static void *_p_SBMLUnitsConverterTo_p_SBMLConverter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLConverter *)  ((SBMLUnitsConverter *) x));
}
static void *_p_MathFilterTo_p_ElementFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ElementFilter *)  ((MathFilter *) x));
}
static void *_p_ISBMLExtensionNamespacesTo_p_SBMLNamespaces(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLNamespaces *)  ((ISBMLExtensionNamespaces *) x));
}
static void *_p_SBMLExternalValidatorTo_p_SBMLValidator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBMLValidator *)  ((SBMLExternalValidator *) x));
}
static void *_p_SpeciesReferenceTo_p_SimpleSpeciesReference(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SimpleSpeciesReference *)  ((SpeciesReference *) x));
}
static void *_p_ModifierSpeciesReferenceTo_p_SimpleSpeciesReference(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SimpleSpeciesReference *)  ((ModifierSpeciesReference *) x));
}
static void *_p_XMLOutputStringStreamTo_p_XMLOutputStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((XMLOutputStream *)  ((XMLOutputStringStream *) x));
}
static void *_p_XMLOwningOutputStringStreamTo_p_XMLOutputStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((XMLOutputStream *) (XMLOutputStringStream *) ((XMLOwningOutputStringStream *) x));
}
static void *_p_XMLOutputFileStreamTo_p_XMLOutputStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((XMLOutputStream *)  ((XMLOutputFileStream *) x));
}
static void *_p_XMLOwningOutputFileStreamTo_p_XMLOutputStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((XMLOutputStream *) (XMLOutputFileStream *) ((XMLOwningOutputFileStream *) x));
}
static void *_p_ListOfReactionsTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfReactions *) x));
}
static void *_p_ListOfLocalParametersTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *) (ListOfParameters *) ((ListOfLocalParameters *) x));
}
static void *_p_ListOfParametersTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfParameters *) x));
}
static void *_p_ListOfRulesTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfRules *) x));
}
static void *_p_ListOfEventsTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfEvents *) x));
}
static void *_p_ListOfCompartmentsTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfCompartments *) x));
}
static void *_p_ListOfCompartmentTypesTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfCompartmentTypes *) x));
}
static void *_p_ListOfUnitDefinitionsTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfUnitDefinitions *) x));
}
static void *_p_ListOfFunctionDefinitionsTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfFunctionDefinitions *) x));
}
static void *_p_ListOfSpeciesTypesTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfSpeciesTypes *) x));
}
static void *_p_ListOfSpeciesReferencesTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfSpeciesReferences *) x));
}
static void *_p_ListOfInitialAssignmentsTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfInitialAssignments *) x));
}
static void *_p_ListOfEventAssignmentsTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfEventAssignments *) x));
}
static void *_p_ListOfConstraintsTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfConstraints *) x));
}
static void *_p_ListOfUnitsTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfUnits *) x));
}
static void *_p_ListOfSpeciesTo_p_ListOf(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOf *)  ((ListOfSpecies *) x));
}
static void *_p_XMLOwningOutputStringStreamTo_p_XMLOutputStringStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((XMLOutputStringStream *)  ((XMLOwningOutputStringStream *) x));
}
static void *_p_XMLOwningOutputFileStreamTo_p_XMLOutputFileStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((XMLOutputFileStream *)  ((XMLOwningOutputFileStream *) x));
}
static void *_p_ListOfLocalParametersTo_p_ListOfParameters(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ListOfParameters *)  ((ListOfLocalParameters *) x));
}
static void *_p_XMLNodeTo_p_XMLToken(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((XMLToken *)  ((XMLNode *) x));
}
static void *_p_SBMLDocumentPluginTo_p_SBasePlugin(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBasePlugin *)  ((SBMLDocumentPlugin *) x));
}
static void *_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ostream< char,std::char_traits< char > > *)  ((std::basic_ostringstream< char,std::char_traits< char >,std::allocator< char > > *) x));
}
static void *_p_SBMLErrorLogTo_p_XMLErrorLog(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((XMLErrorLog *)  ((SBMLErrorLog *) x));
}
static void *_p_LocalParameterTo_p_Parameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Parameter *)  ((LocalParameter *) x));
}
static void *_p_SBMLErrorTo_p_XMLError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((XMLError *)  ((SBMLError *) x));
}
static void *_p_ConstraintTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((Constraint *) x));
}
static void *_p_RateRuleTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (Rule *) ((RateRule *) x));
}
static void *_p_ListOfTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((ListOf *) x));
}
static void *_p_UnitTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((Unit *) x));
}
static void *_p_ListOfFunctionDefinitionsTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfFunctionDefinitions *) x));
}
static void *_p_ListOfUnitDefinitionsTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfUnitDefinitions *) x));
}
static void *_p_SimpleSpeciesReferenceTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((SimpleSpeciesReference *) x));
}
static void *_p_SpeciesReferenceTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (SimpleSpeciesReference *) ((SpeciesReference *) x));
}
static void *_p_ModifierSpeciesReferenceTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (SimpleSpeciesReference *) ((ModifierSpeciesReference *) x));
}
static void *_p_InitialAssignmentTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((InitialAssignment *) x));
}
static void *_p_RuleTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((Rule *) x));
}
static void *_p_ListOfLocalParametersTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *)(ListOfParameters *) ((ListOfLocalParameters *) x));
}
static void *_p_ListOfParametersTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfParameters *) x));
}
static void *_p_EventAssignmentTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((EventAssignment *) x));
}
static void *_p_AssignmentRuleTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (Rule *) ((AssignmentRule *) x));
}
static void *_p_SBMLDocumentTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((SBMLDocument *) x));
}
static void *_p_FunctionDefinitionTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((FunctionDefinition *) x));
}
static void *_p_UnitDefinitionTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((UnitDefinition *) x));
}
static void *_p_ListOfInitialAssignmentsTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfInitialAssignments *) x));
}
static void *_p_AlgebraicRuleTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (Rule *) ((AlgebraicRule *) x));
}
static void *_p_ListOfEventAssignmentsTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfEventAssignments *) x));
}
static void *_p_ListOfCompartmentTypesTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfCompartmentTypes *) x));
}
static void *_p_EventTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((Event *) x));
}
static void *_p_CompartmentTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((Compartment *) x));
}
static void *_p_KineticLawTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((KineticLaw *) x));
}
static void *_p_ListOfEventsTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfEvents *) x));
}
static void *_p_StoichiometryMathTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((StoichiometryMath *) x));
}
static void *_p_ModelTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((Model *) x));
}
static void *_p_ListOfSpeciesTypesTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfSpeciesTypes *) x));
}
static void *_p_ListOfRulesTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfRules *) x));
}
static void *_p_ListOfSpeciesReferencesTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfSpeciesReferences *) x));
}
static void *_p_ListOfConstraintsTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfConstraints *) x));
}
static void *_p_DelayTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((Delay *) x));
}
static void *_p_PriorityTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((Priority *) x));
}
static void *_p_CompartmentTypeTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((CompartmentType *) x));
}
static void *_p_ListOfReactionsTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfReactions *) x));
}
static void *_p_LocalParameterTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (Parameter *) ((LocalParameter *) x));
}
static void *_p_ParameterTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((Parameter *) x));
}
static void *_p_ListOfSpeciesTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfSpecies *) x));
}
static void *_p_SpeciesTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((Species *) x));
}
static void *_p_TriggerTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((Trigger *) x));
}
static void *_p_ListOfUnitsTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfUnits *) x));
}
static void *_p_SpeciesTypeTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((SpeciesType *) x));
}
static void *_p_ReactionTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *)  ((Reaction *) x));
}
static void *_p_ListOfCompartmentsTo_p_SBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SBase *) (ListOf *) ((ListOfCompartments *) x));
}
static swig_type_info _swigt__p_ASTBasePlugin = {"_p_ASTBasePlugin", "ASTBasePlugin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ASTNode = {"_p_ASTNode", "ASTNode *|ASTNode_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ASTNodeType_t = {"_p_ASTNodeType_t", "enum ASTNodeType_t *|ASTNodeType_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ASTNodeValues_t = {"_p_ASTNodeValues_t", "ASTNodeValues_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AlgebraicRule = {"_p_AlgebraicRule", "AlgebraicRule_t *|AlgebraicRule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AllowedChildrenType_t = {"_p_AllowedChildrenType_t", "enum AllowedChildrenType_t *|AllowedChildrenType_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AssignmentRule = {"_p_AssignmentRule", "AssignmentRule_t *|AssignmentRule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BiolQualifierType_t = {"_p_BiolQualifierType_t", "enum BiolQualifierType_t *|BiolQualifierType_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CVTerm = {"_p_CVTerm", "CVTerm *|CVTerm_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Callback = {"_p_Callback", "Callback *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CallbackRegistry = {"_p_CallbackRegistry", "CallbackRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Compartment = {"_p_Compartment", "Compartment_t *|Compartment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CompartmentType = {"_p_CompartmentType", "CompartmentType *|CompartmentType_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Constraint = {"_p_Constraint", "Constraint_t *|Constraint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConversionOption = {"_p_ConversionOption", "ConversionOption_t *|ConversionOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConversionOptionType_t = {"_p_ConversionOptionType_t", "enum ConversionOptionType_t *|ConversionOptionType_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConversionProperties = {"_p_ConversionProperties", "ConversionProperties_t *|ConversionProperties *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Date = {"_p_Date", "Date *|Date_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DefinitionURLRegistry = {"_p_DefinitionURLRegistry", "DefinitionURLRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Delay = {"_p_Delay", "Delay *|Delay_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ElementFilter = {"_p_ElementFilter", "ElementFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ElementTransformer = {"_p_ElementTransformer", "ElementTransformer_t *|ElementTransformer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Event = {"_p_Event", "Event *|Event_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EventAssignment = {"_p_EventAssignment", "EventAssignment_t *|EventAssignment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ExpectedAttributes = {"_p_ExpectedAttributes", "ExpectedAttributes *|ExpectedAttributes_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ExtendedMathType_t = {"_p_ExtendedMathType_t", "enum ExtendedMathType_t *|ExtendedMathType_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FormulaUnitsData = {"_p_FormulaUnitsData", "FormulaUnitsData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FunctionDefinition = {"_p_FunctionDefinition", "FunctionDefinition_t *|FunctionDefinition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ISBMLExtensionNamespaces = {"_p_ISBMLExtensionNamespaces", "SBMLExtensionNamespaces_t *|ISBMLExtensionNamespaces *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IdList = {"_p_IdList", "IdList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IdentifierTransformer = {"_p_IdentifierTransformer", "IdentifierTransformer_t *|IdentifierTransformer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InitialAssignment = {"_p_InitialAssignment", "InitialAssignment_t *|InitialAssignment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_KineticLaw = {"_p_KineticLaw", "KineticLaw *|KineticLaw_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_L3ParserGrammarLineType_t = {"_p_L3ParserGrammarLineType_t", "enum L3ParserGrammarLineType_t *|L3ParserGrammarLineType_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_L3ParserSettings = {"_p_L3ParserSettings", "L3ParserSettings *|L3ParserSettings_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_List = {"_p_List", "List *|List_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListNode = {"_p_ListNode", "ListNode *|ListNode_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOf = {"_p_ListOf", "ListOf *|ListOf_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfCompartmentTypes = {"_p_ListOfCompartmentTypes", "ListOfCompartmentTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfCompartments = {"_p_ListOfCompartments", "ListOfCompartments *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfConstraints = {"_p_ListOfConstraints", "ListOfConstraints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfEventAssignments = {"_p_ListOfEventAssignments", "ListOfEventAssignments *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfEvents = {"_p_ListOfEvents", "ListOfEvents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfFunctionDefinitions = {"_p_ListOfFunctionDefinitions", "ListOfFunctionDefinitions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfInitialAssignments = {"_p_ListOfInitialAssignments", "ListOfInitialAssignments *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfLocalParameters = {"_p_ListOfLocalParameters", "ListOfLocalParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfParameters = {"_p_ListOfParameters", "ListOfParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfReactions = {"_p_ListOfReactions", "ListOfReactions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfRules = {"_p_ListOfRules", "ListOfRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfSpecies = {"_p_ListOfSpecies", "ListOfSpecies *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfSpeciesReferences = {"_p_ListOfSpeciesReferences", "ListOfSpeciesReferences *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfSpeciesTypes = {"_p_ListOfSpeciesTypes", "ListOfSpeciesTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfUnitDefinitions = {"_p_ListOfUnitDefinitions", "ListOfUnitDefinitions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListOfUnits = {"_p_ListOfUnits", "ListOfUnits *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListWrapperT_ASTNode_t = {"_p_ListWrapperT_ASTNode_t", "ListWrapper< ASTNode > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListWrapperT_CVTerm_t = {"_p_ListWrapperT_CVTerm_t", "ListWrapper< CVTerm > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListWrapperT_Date_t = {"_p_ListWrapperT_Date_t", "ListWrapper< Date > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListWrapperT_ModelCreator_t = {"_p_ListWrapperT_ModelCreator_t", "ListWrapper< ModelCreator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListWrapperT_SBMLNamespaces_t = {"_p_ListWrapperT_SBMLNamespaces_t", "ListWrapper< SBMLNamespaces > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ListWrapperT_SBase_t = {"_p_ListWrapperT_SBase_t", "ListWrapper< SBase > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LocalParameter = {"_p_LocalParameter", "LocalParameter *|LocalParameter_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MathFilter = {"_p_MathFilter", "MathFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Model = {"_p_Model", "Model *|Model_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ModelCreator = {"_p_ModelCreator", "ModelCreator *|ModelCreator_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ModelHistory = {"_p_ModelHistory", "ModelHistory *|ModelHistory_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ModelQualifierType_t = {"_p_ModelQualifierType_t", "enum ModelQualifierType_t *|ModelQualifierType_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ModifierSpeciesReference = {"_p_ModifierSpeciesReference", "ModifierSpeciesReference *|ModifierSpeciesReference_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OperationReturnValues_t = {"_p_OperationReturnValues_t", "enum OperationReturnValues_t *|OperationReturnValues_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Parameter = {"_p_Parameter", "Parameter *|Parameter_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ParseLogType_t = {"_p_ParseLogType_t", "enum ParseLogType_t *|ParseLogType_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Priority = {"_p_Priority", "Priority *|Priority_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QualifierType_t = {"_p_QualifierType_t", "enum QualifierType_t *|QualifierType_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RDFAnnotationParser = {"_p_RDFAnnotationParser", "RDFAnnotationParser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RateRule = {"_p_RateRule", "RateRule_t *|RateRule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Reaction = {"_p_Reaction", "Reaction_t *|Reaction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Rule = {"_p_Rule", "Rule_t *|Rule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RuleType_t = {"_p_RuleType_t", "enum RuleType_t *|RuleType_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLConstructorException = {"_p_SBMLConstructorException", "SBMLConstructorException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLConverter = {"_p_SBMLConverter", "SBMLConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLConverterRegistry = {"_p_SBMLConverterRegistry", "SBMLConverterRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLDocument = {"_p_SBMLDocument", "SBMLDocument_t *|SBMLDocument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLDocumentPlugin = {"_p_SBMLDocumentPlugin", "SBMLDocumentPlugin_t *|SBMLDocumentPlugin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLError = {"_p_SBMLError", "SBMLError *|SBMLError_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLErrorCategory_t = {"_p_SBMLErrorCategory_t", "enum SBMLErrorCategory_t *|SBMLErrorCategory_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLErrorCode_t = {"_p_SBMLErrorCode_t", "enum SBMLErrorCode_t *|SBMLErrorCode_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLErrorLog = {"_p_SBMLErrorLog", "SBMLErrorLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLErrorSeverity_t = {"_p_SBMLErrorSeverity_t", "enum SBMLErrorSeverity_t *|SBMLErrorSeverity_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLExtension = {"_p_SBMLExtension", "SBMLExtension *|SBMLExtension_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLExtensionException = {"_p_SBMLExtensionException", "SBMLExtensionException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLExtensionRegistry = {"_p_SBMLExtensionRegistry", "SBMLExtensionRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLExternalValidator = {"_p_SBMLExternalValidator", "SBMLExternalValidator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLFunctionDefinitionConverter = {"_p_SBMLFunctionDefinitionConverter", "SBMLFunctionDefinitionConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLIdConverter = {"_p_SBMLIdConverter", "SBMLIdConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLInferUnitsConverter = {"_p_SBMLInferUnitsConverter", "SBMLInferUnitsConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLInitialAssignmentConverter = {"_p_SBMLInitialAssignmentConverter", "SBMLInitialAssignmentConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLLevel1Version1Converter = {"_p_SBMLLevel1Version1Converter", "SBMLLevel1Version1Converter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLLevelVersionConverter = {"_p_SBMLLevelVersionConverter", "SBMLLevelVersionConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLLocalParameterConverter = {"_p_SBMLLocalParameterConverter", "SBMLLocalParameterConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLNamespaces = {"_p_SBMLNamespaces", "SBMLNamespaces_t *|SBMLNamespaces *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLReactionConverter = {"_p_SBMLReactionConverter", "SBMLReactionConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLReader = {"_p_SBMLReader", "SBMLReader *|SBMLReader_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLRuleConverter = {"_p_SBMLRuleConverter", "SBMLRuleConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLStripPackageConverter = {"_p_SBMLStripPackageConverter", "SBMLStripPackageConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLTransforms = {"_p_SBMLTransforms", "SBMLTransforms *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLTypeCode_t = {"_p_SBMLTypeCode_t", "enum SBMLTypeCode_t *|SBMLTypeCode_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLUnitsConverter = {"_p_SBMLUnitsConverter", "SBMLUnitsConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLValidator = {"_p_SBMLValidator", "SBMLValidator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBMLWriter = {"_p_SBMLWriter", "SBMLWriter *|SBMLWriter_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBO = {"_p_SBO", "SBO *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBase = {"_p_SBase", "SBase_t *|SBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBaseExtensionPoint = {"_p_SBaseExtensionPoint", "SBaseExtensionPoint_t *|SBaseExtensionPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBasePlugin = {"_p_SBasePlugin", "SBasePlugin_t *|SBasePlugin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SBasePluginCreatorBase = {"_p_SBasePluginCreatorBase", "SBasePluginCreatorBase_t *|SBasePluginCreatorBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SimpleSpeciesReference = {"_p_SimpleSpeciesReference", "SimpleSpeciesReference *|SpeciesReference_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Species = {"_p_Species", "Species_t *|Species *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SpeciesReference = {"_p_SpeciesReference", "SpeciesReference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SpeciesType = {"_p_SpeciesType", "SpeciesType *|SpeciesType_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StoichiometryMath = {"_p_StoichiometryMath", "StoichiometryMath_t *|StoichiometryMath *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StringBuffer_t = {"_p_StringBuffer_t", "StringBuffer_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SupportedPackageURIList = {"_p_SupportedPackageURIList", "SupportedPackageURIList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SupportedPackageURIListIter = {"_p_SupportedPackageURIListIter", "SupportedPackageURIListIter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SyntaxChecker = {"_p_SyntaxChecker", "SyntaxChecker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Trigger = {"_p_Trigger", "Trigger *|Trigger_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Unit = {"_p_Unit", "Unit_t *|Unit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UnitDefinition = {"_p_UnitDefinition", "UnitDefinition_t *|UnitDefinition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UnitFormulaFormatter = {"_p_UnitFormulaFormatter", "UnitFormulaFormatter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UnitKind_t = {"_p_UnitKind_t", "enum UnitKind_t *|UnitKind_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLAttributes = {"_p_XMLAttributes", "XMLAttributes *|XMLAttributes_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLConstructorException = {"_p_XMLConstructorException", "XMLConstructorException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLError = {"_p_XMLError", "XMLError *|XMLError_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLErrorCategory_t = {"_p_XMLErrorCategory_t", "enum XMLErrorCategory_t *|XMLErrorCategory_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLErrorCode_t = {"_p_XMLErrorCode_t", "enum XMLErrorCode_t *|XMLErrorCode_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLErrorLog = {"_p_XMLErrorLog", "XMLErrorLog *|XMLErrorLog_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLErrorSeverityOverride_t = {"_p_XMLErrorSeverityOverride_t", "enum XMLErrorSeverityOverride_t *|XMLErrorSeverityOverride_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLErrorSeverity_t = {"_p_XMLErrorSeverity_t", "enum XMLErrorSeverity_t *|XMLErrorSeverity_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLInputStream = {"_p_XMLInputStream", "XMLInputStream *|XMLInputStream_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLNamespaces = {"_p_XMLNamespaces", "XMLNamespaces_t *|XMLNamespaces *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLNode = {"_p_XMLNode", "XMLNode *|XMLNode_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLOutputFileStream = {"_p_XMLOutputFileStream", "XMLOutputFileStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLOutputStream = {"_p_XMLOutputStream", "XMLOutputStream *|XMLOutputStream_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLOutputStringStream = {"_p_XMLOutputStringStream", "XMLOutputStringStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLOwningOutputFileStream = {"_p_XMLOwningOutputFileStream", "XMLOwningOutputFileStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLOwningOutputStringStream = {"_p_XMLOwningOutputStringStream", "XMLOwningOutputStringStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLToken = {"_p_XMLToken", "XMLToken_t *|XMLToken *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLTriple = {"_p_XMLTriple", "XMLTriple *|XMLTriple_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char_type = {"_p_char_type", "char_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_iterator = {"_p_const_iterator", "const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int_type = {"_p_int_type", "int_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iterator = {"_p_iterator", "iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_off_type = {"_p_off_type", "off_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_pos_type = {"_p_pos_type", "pos_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_state_type = {"_p_state_type", "state_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_iosT_char_std__char_traitsT_char_t_t = {"_p_std__basic_iosT_char_std__char_traitsT_char_t_t", "std::basic_ios< char,std::char_traits< char > > *|std::ios *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t = {"_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t", "std::basic_ostream< char > *|std::basic_ostream< char,std::char_traits< char > > *|std::ostream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", "std::basic_ostringstream< char > *|std::ostringstream *|std::basic_ostringstream< char,std::char_traits< char >,std::allocator< char > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_streambufT_char_std__char_traitsT_char_t_t = {"_p_std__basic_streambufT_char_std__char_traitsT_char_t_t", "std::basic_streambuf< char,std::char_traits< char > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", "std::basic_string< char > *|std::basic_string< char,std::char_traits< char >,std::allocator< char > > *|std::string *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator = {"_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator", "std::basic_string< char >::iterator *|std::basic_string< char,std::char_traits< char >,std::allocator< char > >::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ios_base__openmode = {"_p_std__ios_base__openmode", "std::ios_base::openmode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__multimapT_int_int_t = {"_p_std__multimapT_int_int_t", "ParentMap *|std::multimap< int,int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__multimapT_int_int_t__iterator = {"_p_std__multimapT_int_int_t__iterator", "ParentIter *|std::multimap< int,int >::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__multimapT_int_int_t__iterator_std__multimapT_int_int_t__iterator_t = {"_p_std__pairT_std__multimapT_int_int_t__iterator_std__multimapT_int_int_t__iterator_t", "ParentRange *|std::pair< std::multimap< int,int >::iterator,std::multimap< int,int >::iterator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__stringstream = {"_p_std__stringstream", "std::stringstream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ASTBasePlugin_p_t = {"_p_std__vectorT_ASTBasePlugin_p_t", "std::vector< ASTBasePlugin * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_XMLError_p_t = {"_p_std__vectorT_XMLError_p_t", "std::vector< XMLError * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t = {"_p_std__vectorT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t", "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > *|std::vector< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t = {"_p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t", "RuleMap *|std::vector< std::pair< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,ASTNode * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t__iterator = {"_p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t__iterator", "RuleMapIter *|std::vector< std::pair< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,ASTNode * > >::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_unsigned_int_t = {"_p_std__vectorT_unsigned_int_t", "std::vector< unsigned int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_ASTBasePlugin,
  &_swigt__p_ASTNode,
  &_swigt__p_ASTNodeType_t,
  &_swigt__p_ASTNodeValues_t,
  &_swigt__p_AlgebraicRule,
  &_swigt__p_AllowedChildrenType_t,
  &_swigt__p_AssignmentRule,
  &_swigt__p_BiolQualifierType_t,
  &_swigt__p_CVTerm,
  &_swigt__p_Callback,
  &_swigt__p_CallbackRegistry,
  &_swigt__p_Compartment,
  &_swigt__p_CompartmentType,
  &_swigt__p_Constraint,
  &_swigt__p_ConversionOption,
  &_swigt__p_ConversionOptionType_t,
  &_swigt__p_ConversionProperties,
  &_swigt__p_Date,
  &_swigt__p_DefinitionURLRegistry,
  &_swigt__p_Delay,
  &_swigt__p_ElementFilter,
  &_swigt__p_ElementTransformer,
  &_swigt__p_Event,
  &_swigt__p_EventAssignment,
  &_swigt__p_ExpectedAttributes,
  &_swigt__p_ExtendedMathType_t,
  &_swigt__p_FormulaUnitsData,
  &_swigt__p_FunctionDefinition,
  &_swigt__p_ISBMLExtensionNamespaces,
  &_swigt__p_IdList,
  &_swigt__p_IdentifierTransformer,
  &_swigt__p_InitialAssignment,
  &_swigt__p_KineticLaw,
  &_swigt__p_L3ParserGrammarLineType_t,
  &_swigt__p_L3ParserSettings,
  &_swigt__p_List,
  &_swigt__p_ListNode,
  &_swigt__p_ListOf,
  &_swigt__p_ListOfCompartmentTypes,
  &_swigt__p_ListOfCompartments,
  &_swigt__p_ListOfConstraints,
  &_swigt__p_ListOfEventAssignments,
  &_swigt__p_ListOfEvents,
  &_swigt__p_ListOfFunctionDefinitions,
  &_swigt__p_ListOfInitialAssignments,
  &_swigt__p_ListOfLocalParameters,
  &_swigt__p_ListOfParameters,
  &_swigt__p_ListOfReactions,
  &_swigt__p_ListOfRules,
  &_swigt__p_ListOfSpecies,
  &_swigt__p_ListOfSpeciesReferences,
  &_swigt__p_ListOfSpeciesTypes,
  &_swigt__p_ListOfUnitDefinitions,
  &_swigt__p_ListOfUnits,
  &_swigt__p_ListWrapperT_ASTNode_t,
  &_swigt__p_ListWrapperT_CVTerm_t,
  &_swigt__p_ListWrapperT_Date_t,
  &_swigt__p_ListWrapperT_ModelCreator_t,
  &_swigt__p_ListWrapperT_SBMLNamespaces_t,
  &_swigt__p_ListWrapperT_SBase_t,
  &_swigt__p_LocalParameter,
  &_swigt__p_MathFilter,
  &_swigt__p_Model,
  &_swigt__p_ModelCreator,
  &_swigt__p_ModelHistory,
  &_swigt__p_ModelQualifierType_t,
  &_swigt__p_ModifierSpeciesReference,
  &_swigt__p_OperationReturnValues_t,
  &_swigt__p_Parameter,
  &_swigt__p_ParseLogType_t,
  &_swigt__p_Priority,
  &_swigt__p_QualifierType_t,
  &_swigt__p_RDFAnnotationParser,
  &_swigt__p_RateRule,
  &_swigt__p_Reaction,
  &_swigt__p_Rule,
  &_swigt__p_RuleType_t,
  &_swigt__p_SBMLConstructorException,
  &_swigt__p_SBMLConverter,
  &_swigt__p_SBMLConverterRegistry,
  &_swigt__p_SBMLDocument,
  &_swigt__p_SBMLDocumentPlugin,
  &_swigt__p_SBMLError,
  &_swigt__p_SBMLErrorCategory_t,
  &_swigt__p_SBMLErrorCode_t,
  &_swigt__p_SBMLErrorLog,
  &_swigt__p_SBMLErrorSeverity_t,
  &_swigt__p_SBMLExtension,
  &_swigt__p_SBMLExtensionException,
  &_swigt__p_SBMLExtensionRegistry,
  &_swigt__p_SBMLExternalValidator,
  &_swigt__p_SBMLFunctionDefinitionConverter,
  &_swigt__p_SBMLIdConverter,
  &_swigt__p_SBMLInferUnitsConverter,
  &_swigt__p_SBMLInitialAssignmentConverter,
  &_swigt__p_SBMLLevel1Version1Converter,
  &_swigt__p_SBMLLevelVersionConverter,
  &_swigt__p_SBMLLocalParameterConverter,
  &_swigt__p_SBMLNamespaces,
  &_swigt__p_SBMLReactionConverter,
  &_swigt__p_SBMLReader,
  &_swigt__p_SBMLRuleConverter,
  &_swigt__p_SBMLStripPackageConverter,
  &_swigt__p_SBMLTransforms,
  &_swigt__p_SBMLTypeCode_t,
  &_swigt__p_SBMLUnitsConverter,
  &_swigt__p_SBMLValidator,
  &_swigt__p_SBMLWriter,
  &_swigt__p_SBO,
  &_swigt__p_SBase,
  &_swigt__p_SBaseExtensionPoint,
  &_swigt__p_SBasePlugin,
  &_swigt__p_SBasePluginCreatorBase,
  &_swigt__p_SimpleSpeciesReference,
  &_swigt__p_Species,
  &_swigt__p_SpeciesReference,
  &_swigt__p_SpeciesType,
  &_swigt__p_StoichiometryMath,
  &_swigt__p_StringBuffer_t,
  &_swigt__p_SupportedPackageURIList,
  &_swigt__p_SupportedPackageURIListIter,
  &_swigt__p_SyntaxChecker,
  &_swigt__p_Trigger,
  &_swigt__p_Unit,
  &_swigt__p_UnitDefinition,
  &_swigt__p_UnitFormulaFormatter,
  &_swigt__p_UnitKind_t,
  &_swigt__p_XMLAttributes,
  &_swigt__p_XMLConstructorException,
  &_swigt__p_XMLError,
  &_swigt__p_XMLErrorCategory_t,
  &_swigt__p_XMLErrorCode_t,
  &_swigt__p_XMLErrorLog,
  &_swigt__p_XMLErrorSeverityOverride_t,
  &_swigt__p_XMLErrorSeverity_t,
  &_swigt__p_XMLInputStream,
  &_swigt__p_XMLNamespaces,
  &_swigt__p_XMLNode,
  &_swigt__p_XMLOutputFileStream,
  &_swigt__p_XMLOutputStream,
  &_swigt__p_XMLOutputStringStream,
  &_swigt__p_XMLOwningOutputFileStream,
  &_swigt__p_XMLOwningOutputStringStream,
  &_swigt__p_XMLToken,
  &_swigt__p_XMLTriple,
  &_swigt__p_allocator_type,
  &_swigt__p_char,
  &_swigt__p_char_type,
  &_swigt__p_const_iterator,
  &_swigt__p_const_reference,
  &_swigt__p_difference_type,
  &_swigt__p_int_type,
  &_swigt__p_iterator,
  &_swigt__p_off_type,
  &_swigt__p_p_PyObject,
  &_swigt__p_pos_type,
  &_swigt__p_reference,
  &_swigt__p_size_type,
  &_swigt__p_state_type,
  &_swigt__p_std__basic_iosT_char_std__char_traitsT_char_t_t,
  &_swigt__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_std__basic_streambufT_char_std__char_traitsT_char_t_t,
  &_swigt__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator,
  &_swigt__p_std__invalid_argument,
  &_swigt__p_std__ios_base__openmode,
  &_swigt__p_std__multimapT_int_int_t,
  &_swigt__p_std__multimapT_int_int_t__iterator,
  &_swigt__p_std__pairT_std__multimapT_int_int_t__iterator_std__multimapT_int_int_t__iterator_t,
  &_swigt__p_std__stringstream,
  &_swigt__p_std__vectorT_ASTBasePlugin_p_t,
  &_swigt__p_std__vectorT_XMLError_p_t,
  &_swigt__p_std__vectorT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t__iterator,
  &_swigt__p_std__vectorT_unsigned_int_t,
  &_swigt__p_swig__SwigPyIterator,
  &_swigt__p_value_type,
};

static swig_cast_info _swigc__p_ASTBasePlugin[] = {  {&_swigt__p_ASTBasePlugin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ASTNode[] = {  {&_swigt__p_ASTNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ASTNodeType_t[] = {  {&_swigt__p_ASTNodeType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ASTNodeValues_t[] = {  {&_swigt__p_ASTNodeValues_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AlgebraicRule[] = {  {&_swigt__p_AlgebraicRule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AllowedChildrenType_t[] = {  {&_swigt__p_AllowedChildrenType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AssignmentRule[] = {  {&_swigt__p_AssignmentRule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BiolQualifierType_t[] = {  {&_swigt__p_BiolQualifierType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CVTerm[] = {  {&_swigt__p_CVTerm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Callback[] = {  {&_swigt__p_Callback, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CallbackRegistry[] = {  {&_swigt__p_CallbackRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Compartment[] = {  {&_swigt__p_Compartment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CompartmentType[] = {  {&_swigt__p_CompartmentType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Constraint[] = {  {&_swigt__p_Constraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConversionOption[] = {  {&_swigt__p_ConversionOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConversionOptionType_t[] = {  {&_swigt__p_ConversionOptionType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConversionProperties[] = {  {&_swigt__p_ConversionProperties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Date[] = {  {&_swigt__p_Date, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DefinitionURLRegistry[] = {  {&_swigt__p_DefinitionURLRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Delay[] = {  {&_swigt__p_Delay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ElementFilter[] = {  {&_swigt__p_ElementFilter, 0, 0, 0},  {&_swigt__p_MathFilter, _p_MathFilterTo_p_ElementFilter, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ElementTransformer[] = {  {&_swigt__p_ElementTransformer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Event[] = {  {&_swigt__p_Event, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EventAssignment[] = {  {&_swigt__p_EventAssignment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ExpectedAttributes[] = {  {&_swigt__p_ExpectedAttributes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ExtendedMathType_t[] = {  {&_swigt__p_ExtendedMathType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FormulaUnitsData[] = {  {&_swigt__p_FormulaUnitsData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FunctionDefinition[] = {  {&_swigt__p_FunctionDefinition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ISBMLExtensionNamespaces[] = {  {&_swigt__p_ISBMLExtensionNamespaces, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IdList[] = {  {&_swigt__p_IdList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IdentifierTransformer[] = {  {&_swigt__p_IdentifierTransformer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InitialAssignment[] = {  {&_swigt__p_InitialAssignment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_KineticLaw[] = {  {&_swigt__p_KineticLaw, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_L3ParserGrammarLineType_t[] = {  {&_swigt__p_L3ParserGrammarLineType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_L3ParserSettings[] = {  {&_swigt__p_L3ParserSettings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_List[] = {  {&_swigt__p_List, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListNode[] = {  {&_swigt__p_ListNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOf[] = {  {&_swigt__p_ListOfReactions, _p_ListOfReactionsTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfLocalParameters, _p_ListOfLocalParametersTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfParameters, _p_ListOfParametersTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfEvents, _p_ListOfEventsTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfRules, _p_ListOfRulesTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfCompartments, _p_ListOfCompartmentsTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfCompartmentTypes, _p_ListOfCompartmentTypesTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfUnitDefinitions, _p_ListOfUnitDefinitionsTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfFunctionDefinitions, _p_ListOfFunctionDefinitionsTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfSpeciesTypes, _p_ListOfSpeciesTypesTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfSpeciesReferences, _p_ListOfSpeciesReferencesTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfInitialAssignments, _p_ListOfInitialAssignmentsTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfEventAssignments, _p_ListOfEventAssignmentsTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfConstraints, _p_ListOfConstraintsTo_p_ListOf, 0, 0},  {&_swigt__p_ListOfUnits, _p_ListOfUnitsTo_p_ListOf, 0, 0},  {&_swigt__p_ListOf, 0, 0, 0},  {&_swigt__p_ListOfSpecies, _p_ListOfSpeciesTo_p_ListOf, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfCompartmentTypes[] = {  {&_swigt__p_ListOfCompartmentTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfCompartments[] = {  {&_swigt__p_ListOfCompartments, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfConstraints[] = {  {&_swigt__p_ListOfConstraints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfEventAssignments[] = {  {&_swigt__p_ListOfEventAssignments, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfEvents[] = {  {&_swigt__p_ListOfEvents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfFunctionDefinitions[] = {  {&_swigt__p_ListOfFunctionDefinitions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfInitialAssignments[] = {  {&_swigt__p_ListOfInitialAssignments, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfLocalParameters[] = {  {&_swigt__p_ListOfLocalParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfParameters[] = {  {&_swigt__p_ListOfParameters, 0, 0, 0},  {&_swigt__p_ListOfLocalParameters, _p_ListOfLocalParametersTo_p_ListOfParameters, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfReactions[] = {  {&_swigt__p_ListOfReactions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfRules[] = {  {&_swigt__p_ListOfRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfSpecies[] = {  {&_swigt__p_ListOfSpecies, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfSpeciesReferences[] = {  {&_swigt__p_ListOfSpeciesReferences, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfSpeciesTypes[] = {  {&_swigt__p_ListOfSpeciesTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfUnitDefinitions[] = {  {&_swigt__p_ListOfUnitDefinitions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListOfUnits[] = {  {&_swigt__p_ListOfUnits, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListWrapperT_ASTNode_t[] = {  {&_swigt__p_ListWrapperT_ASTNode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListWrapperT_CVTerm_t[] = {  {&_swigt__p_ListWrapperT_CVTerm_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListWrapperT_Date_t[] = {  {&_swigt__p_ListWrapperT_Date_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListWrapperT_ModelCreator_t[] = {  {&_swigt__p_ListWrapperT_ModelCreator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListWrapperT_SBMLNamespaces_t[] = {  {&_swigt__p_ListWrapperT_SBMLNamespaces_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ListWrapperT_SBase_t[] = {  {&_swigt__p_ListWrapperT_SBase_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LocalParameter[] = {  {&_swigt__p_LocalParameter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MathFilter[] = {  {&_swigt__p_MathFilter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Model[] = {  {&_swigt__p_Model, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ModelCreator[] = {  {&_swigt__p_ModelCreator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ModelHistory[] = {  {&_swigt__p_ModelHistory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ModelQualifierType_t[] = {  {&_swigt__p_ModelQualifierType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ModifierSpeciesReference[] = {  {&_swigt__p_ModifierSpeciesReference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OperationReturnValues_t[] = {  {&_swigt__p_OperationReturnValues_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Parameter[] = {  {&_swigt__p_Parameter, 0, 0, 0},  {&_swigt__p_LocalParameter, _p_LocalParameterTo_p_Parameter, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ParseLogType_t[] = {  {&_swigt__p_ParseLogType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Priority[] = {  {&_swigt__p_Priority, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QualifierType_t[] = {  {&_swigt__p_QualifierType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RDFAnnotationParser[] = {  {&_swigt__p_RDFAnnotationParser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RateRule[] = {  {&_swigt__p_RateRule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Reaction[] = {  {&_swigt__p_Reaction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Rule[] = {  {&_swigt__p_Rule, 0, 0, 0},  {&_swigt__p_AlgebraicRule, _p_AlgebraicRuleTo_p_Rule, 0, 0},  {&_swigt__p_AssignmentRule, _p_AssignmentRuleTo_p_Rule, 0, 0},  {&_swigt__p_RateRule, _p_RateRuleTo_p_Rule, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RuleType_t[] = {  {&_swigt__p_RuleType_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLConstructorException[] = {  {&_swigt__p_SBMLConstructorException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLConverter[] = {  {&_swigt__p_SBMLConverter, 0, 0, 0},  {&_swigt__p_SBMLFunctionDefinitionConverter, _p_SBMLFunctionDefinitionConverterTo_p_SBMLConverter, 0, 0},  {&_swigt__p_SBMLIdConverter, _p_SBMLIdConverterTo_p_SBMLConverter, 0, 0},  {&_swigt__p_SBMLInferUnitsConverter, _p_SBMLInferUnitsConverterTo_p_SBMLConverter, 0, 0},  {&_swigt__p_SBMLInitialAssignmentConverter, _p_SBMLInitialAssignmentConverterTo_p_SBMLConverter, 0, 0},  {&_swigt__p_SBMLLevelVersionConverter, _p_SBMLLevelVersionConverterTo_p_SBMLConverter, 0, 0},  {&_swigt__p_SBMLLevel1Version1Converter, _p_SBMLLevel1Version1ConverterTo_p_SBMLConverter, 0, 0},  {&_swigt__p_SBMLLocalParameterConverter, _p_SBMLLocalParameterConverterTo_p_SBMLConverter, 0, 0},  {&_swigt__p_SBMLReactionConverter, _p_SBMLReactionConverterTo_p_SBMLConverter, 0, 0},  {&_swigt__p_SBMLRuleConverter, _p_SBMLRuleConverterTo_p_SBMLConverter, 0, 0},  {&_swigt__p_SBMLStripPackageConverter, _p_SBMLStripPackageConverterTo_p_SBMLConverter, 0, 0},  {&_swigt__p_SBMLUnitsConverter, _p_SBMLUnitsConverterTo_p_SBMLConverter, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLConverterRegistry[] = {  {&_swigt__p_SBMLConverterRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLDocument[] = {  {&_swigt__p_SBMLDocument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLDocumentPlugin[] = {  {&_swigt__p_SBMLDocumentPlugin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLError[] = {  {&_swigt__p_SBMLError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLErrorCategory_t[] = {  {&_swigt__p_SBMLErrorCategory_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLErrorCode_t[] = {  {&_swigt__p_SBMLErrorCode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLErrorLog[] = {  {&_swigt__p_SBMLErrorLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLErrorSeverity_t[] = {  {&_swigt__p_SBMLErrorSeverity_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLExtension[] = {  {&_swigt__p_SBMLExtension, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLExtensionException[] = {  {&_swigt__p_SBMLExtensionException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLExtensionRegistry[] = {  {&_swigt__p_SBMLExtensionRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLExternalValidator[] = {  {&_swigt__p_SBMLExternalValidator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLFunctionDefinitionConverter[] = {  {&_swigt__p_SBMLFunctionDefinitionConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLIdConverter[] = {  {&_swigt__p_SBMLIdConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLInferUnitsConverter[] = {  {&_swigt__p_SBMLInferUnitsConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLInitialAssignmentConverter[] = {  {&_swigt__p_SBMLInitialAssignmentConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLLevel1Version1Converter[] = {  {&_swigt__p_SBMLLevel1Version1Converter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLLevelVersionConverter[] = {  {&_swigt__p_SBMLLevelVersionConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLLocalParameterConverter[] = {  {&_swigt__p_SBMLLocalParameterConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLNamespaces[] = {  {&_swigt__p_SBMLNamespaces, 0, 0, 0},  {&_swigt__p_ISBMLExtensionNamespaces, _p_ISBMLExtensionNamespacesTo_p_SBMLNamespaces, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLReactionConverter[] = {  {&_swigt__p_SBMLReactionConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLReader[] = {  {&_swigt__p_SBMLReader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLRuleConverter[] = {  {&_swigt__p_SBMLRuleConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLStripPackageConverter[] = {  {&_swigt__p_SBMLStripPackageConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLTransforms[] = {  {&_swigt__p_SBMLTransforms, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLTypeCode_t[] = {  {&_swigt__p_SBMLTypeCode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLUnitsConverter[] = {  {&_swigt__p_SBMLUnitsConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLValidator[] = {  {&_swigt__p_SBMLValidator, 0, 0, 0},  {&_swigt__p_SBMLExternalValidator, _p_SBMLExternalValidatorTo_p_SBMLValidator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBMLWriter[] = {  {&_swigt__p_SBMLWriter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBO[] = {  {&_swigt__p_SBO, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBase[] = {  {&_swigt__p_Constraint, _p_ConstraintTo_p_SBase, 0, 0},  {&_swigt__p_RateRule, _p_RateRuleTo_p_SBase, 0, 0},  {&_swigt__p_ListOfFunctionDefinitions, _p_ListOfFunctionDefinitionsTo_p_SBase, 0, 0},  {&_swigt__p_ListOfUnitDefinitions, _p_ListOfUnitDefinitionsTo_p_SBase, 0, 0},  {&_swigt__p_SimpleSpeciesReference, _p_SimpleSpeciesReferenceTo_p_SBase, 0, 0},  {&_swigt__p_SpeciesReference, _p_SpeciesReferenceTo_p_SBase, 0, 0},  {&_swigt__p_ModifierSpeciesReference, _p_ModifierSpeciesReferenceTo_p_SBase, 0, 0},  {&_swigt__p_Event, _p_EventTo_p_SBase, 0, 0},  {&_swigt__p_EventAssignment, _p_EventAssignmentTo_p_SBase, 0, 0},  {&_swigt__p_InitialAssignment, _p_InitialAssignmentTo_p_SBase, 0, 0},  {&_swigt__p_ListOfLocalParameters, _p_ListOfLocalParametersTo_p_SBase, 0, 0},  {&_swigt__p_ListOfParameters, _p_ListOfParametersTo_p_SBase, 0, 0},  {&_swigt__p_AssignmentRule, _p_AssignmentRuleTo_p_SBase, 0, 0},  {&_swigt__p_SBMLDocument, _p_SBMLDocumentTo_p_SBase, 0, 0},  {&_swigt__p_FunctionDefinition, _p_FunctionDefinitionTo_p_SBase, 0, 0},  {&_swigt__p_UnitDefinition, _p_UnitDefinitionTo_p_SBase, 0, 0},  {&_swigt__p_Model, _p_ModelTo_p_SBase, 0, 0},  {&_swigt__p_ListOfInitialAssignments, _p_ListOfInitialAssignmentsTo_p_SBase, 0, 0},  {&_swigt__p_ListOfEventAssignments, _p_ListOfEventAssignmentsTo_p_SBase, 0, 0},  {&_swigt__p_AlgebraicRule, _p_AlgebraicRuleTo_p_SBase, 0, 0},  {&_swigt__p_Delay, _p_DelayTo_p_SBase, 0, 0},  {&_swigt__p_ListOf, _p_ListOfTo_p_SBase, 0, 0},  {&_swigt__p_ListOfCompartmentTypes, _p_ListOfCompartmentTypesTo_p_SBase, 0, 0},  {&_swigt__p_Compartment, _p_CompartmentTo_p_SBase, 0, 0},  {&_swigt__p_KineticLaw, _p_KineticLawTo_p_SBase, 0, 0},  {&_swigt__p_ListOfEvents, _p_ListOfEventsTo_p_SBase, 0, 0},  {&_swigt__p_StoichiometryMath, _p_StoichiometryMathTo_p_SBase, 0, 0},  {&_swigt__p_Unit, _p_UnitTo_p_SBase, 0, 0},  {&_swigt__p_SBase, 0, 0, 0},  {&_swigt__p_ListOfSpeciesReferences, _p_ListOfSpeciesReferencesTo_p_SBase, 0, 0},  {&_swigt__p_ListOfSpeciesTypes, _p_ListOfSpeciesTypesTo_p_SBase, 0, 0},  {&_swigt__p_ListOfRules, _p_ListOfRulesTo_p_SBase, 0, 0},  {&_swigt__p_Rule, _p_RuleTo_p_SBase, 0, 0},  {&_swigt__p_ListOfConstraints, _p_ListOfConstraintsTo_p_SBase, 0, 0},  {&_swigt__p_Priority, _p_PriorityTo_p_SBase, 0, 0},  {&_swigt__p_ListOfReactions, _p_ListOfReactionsTo_p_SBase, 0, 0},  {&_swigt__p_CompartmentType, _p_CompartmentTypeTo_p_SBase, 0, 0},  {&_swigt__p_LocalParameter, _p_LocalParameterTo_p_SBase, 0, 0},  {&_swigt__p_Parameter, _p_ParameterTo_p_SBase, 0, 0},  {&_swigt__p_ListOfSpecies, _p_ListOfSpeciesTo_p_SBase, 0, 0},  {&_swigt__p_Species, _p_SpeciesTo_p_SBase, 0, 0},  {&_swigt__p_Trigger, _p_TriggerTo_p_SBase, 0, 0},  {&_swigt__p_ListOfUnits, _p_ListOfUnitsTo_p_SBase, 0, 0},  {&_swigt__p_SpeciesType, _p_SpeciesTypeTo_p_SBase, 0, 0},  {&_swigt__p_ListOfCompartments, _p_ListOfCompartmentsTo_p_SBase, 0, 0},  {&_swigt__p_Reaction, _p_ReactionTo_p_SBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBaseExtensionPoint[] = {  {&_swigt__p_SBaseExtensionPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBasePlugin[] = {  {&_swigt__p_SBMLDocumentPlugin, _p_SBMLDocumentPluginTo_p_SBasePlugin, 0, 0},  {&_swigt__p_SBasePlugin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SBasePluginCreatorBase[] = {  {&_swigt__p_SBasePluginCreatorBase, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SimpleSpeciesReference[] = {  {&_swigt__p_SimpleSpeciesReference, 0, 0, 0},  {&_swigt__p_SpeciesReference, _p_SpeciesReferenceTo_p_SimpleSpeciesReference, 0, 0},  {&_swigt__p_ModifierSpeciesReference, _p_ModifierSpeciesReferenceTo_p_SimpleSpeciesReference, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Species[] = {  {&_swigt__p_Species, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SpeciesReference[] = {  {&_swigt__p_SpeciesReference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SpeciesType[] = {  {&_swigt__p_SpeciesType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StoichiometryMath[] = {  {&_swigt__p_StoichiometryMath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StringBuffer_t[] = {  {&_swigt__p_StringBuffer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SupportedPackageURIList[] = {  {&_swigt__p_SupportedPackageURIList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SupportedPackageURIListIter[] = {  {&_swigt__p_SupportedPackageURIListIter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SyntaxChecker[] = {  {&_swigt__p_SyntaxChecker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Trigger[] = {  {&_swigt__p_Trigger, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Unit[] = {  {&_swigt__p_Unit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UnitDefinition[] = {  {&_swigt__p_UnitDefinition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UnitFormulaFormatter[] = {  {&_swigt__p_UnitFormulaFormatter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UnitKind_t[] = {  {&_swigt__p_UnitKind_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLAttributes[] = {  {&_swigt__p_XMLAttributes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLConstructorException[] = {  {&_swigt__p_XMLConstructorException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLError[] = {  {&_swigt__p_XMLError, 0, 0, 0},  {&_swigt__p_SBMLError, _p_SBMLErrorTo_p_XMLError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLErrorCategory_t[] = {  {&_swigt__p_XMLErrorCategory_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLErrorCode_t[] = {  {&_swigt__p_XMLErrorCode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLErrorLog[] = {  {&_swigt__p_XMLErrorLog, 0, 0, 0},  {&_swigt__p_SBMLErrorLog, _p_SBMLErrorLogTo_p_XMLErrorLog, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLErrorSeverityOverride_t[] = {  {&_swigt__p_XMLErrorSeverityOverride_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLErrorSeverity_t[] = {  {&_swigt__p_XMLErrorSeverity_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLInputStream[] = {  {&_swigt__p_XMLInputStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLNamespaces[] = {  {&_swigt__p_XMLNamespaces, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLNode[] = {  {&_swigt__p_XMLNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLOutputFileStream[] = {  {&_swigt__p_XMLOutputFileStream, 0, 0, 0},  {&_swigt__p_XMLOwningOutputFileStream, _p_XMLOwningOutputFileStreamTo_p_XMLOutputFileStream, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLOutputStream[] = {  {&_swigt__p_XMLOutputStringStream, _p_XMLOutputStringStreamTo_p_XMLOutputStream, 0, 0},  {&_swigt__p_XMLOwningOutputStringStream, _p_XMLOwningOutputStringStreamTo_p_XMLOutputStream, 0, 0},  {&_swigt__p_XMLOutputFileStream, _p_XMLOutputFileStreamTo_p_XMLOutputStream, 0, 0},  {&_swigt__p_XMLOwningOutputFileStream, _p_XMLOwningOutputFileStreamTo_p_XMLOutputStream, 0, 0},  {&_swigt__p_XMLOutputStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLOutputStringStream[] = {  {&_swigt__p_XMLOutputStringStream, 0, 0, 0},  {&_swigt__p_XMLOwningOutputStringStream, _p_XMLOwningOutputStringStreamTo_p_XMLOutputStringStream, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLOwningOutputFileStream[] = {  {&_swigt__p_XMLOwningOutputFileStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLOwningOutputStringStream[] = {  {&_swigt__p_XMLOwningOutputStringStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLToken[] = {  {&_swigt__p_XMLToken, 0, 0, 0},  {&_swigt__p_XMLNode, _p_XMLNodeTo_p_XMLToken, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLTriple[] = {  {&_swigt__p_XMLTriple, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char_type[] = {  {&_swigt__p_char_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_iterator[] = {  {&_swigt__p_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_reference[] = {  {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int_type[] = {  {&_swigt__p_int_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iterator[] = {  {&_swigt__p_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_off_type[] = {  {&_swigt__p_off_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_pos_type[] = {  {&_swigt__p_pos_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_reference[] = {  {&_swigt__p_reference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_state_type[] = {  {&_swigt__p_state_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_iosT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {  {&_swigt__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_streambufT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {  {&_swigt__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator[] = {  {&_swigt__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_SBMLConstructorException, _p_SBMLConstructorExceptionTo_p_std__invalid_argument, 0, 0},  {&_swigt__p_XMLConstructorException, _p_XMLConstructorExceptionTo_p_std__invalid_argument, 0, 0},  {&_swigt__p_SBMLExtensionException, _p_SBMLExtensionExceptionTo_p_std__invalid_argument, 0, 0},  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ios_base__openmode[] = {  {&_swigt__p_std__ios_base__openmode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__multimapT_int_int_t[] = {  {&_swigt__p_std__multimapT_int_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__multimapT_int_int_t__iterator[] = {  {&_swigt__p_std__multimapT_int_int_t__iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__multimapT_int_int_t__iterator_std__multimapT_int_int_t__iterator_t[] = {  {&_swigt__p_std__pairT_std__multimapT_int_int_t__iterator_std__multimapT_int_int_t__iterator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__stringstream[] = {  {&_swigt__p_std__stringstream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ASTBasePlugin_p_t[] = {  {&_swigt__p_std__vectorT_ASTBasePlugin_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_XMLError_p_t[] = {  {&_swigt__p_std__vectorT_XMLError_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t[] = {  {&_swigt__p_std__vectorT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t__iterator[] = {  {&_swigt__p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t__iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_unsigned_int_t[] = {  {&_swigt__p_std__vectorT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__SwigPyIterator[] = {  {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_ASTBasePlugin,
  _swigc__p_ASTNode,
  _swigc__p_ASTNodeType_t,
  _swigc__p_ASTNodeValues_t,
  _swigc__p_AlgebraicRule,
  _swigc__p_AllowedChildrenType_t,
  _swigc__p_AssignmentRule,
  _swigc__p_BiolQualifierType_t,
  _swigc__p_CVTerm,
  _swigc__p_Callback,
  _swigc__p_CallbackRegistry,
  _swigc__p_Compartment,
  _swigc__p_CompartmentType,
  _swigc__p_Constraint,
  _swigc__p_ConversionOption,
  _swigc__p_ConversionOptionType_t,
  _swigc__p_ConversionProperties,
  _swigc__p_Date,
  _swigc__p_DefinitionURLRegistry,
  _swigc__p_Delay,
  _swigc__p_ElementFilter,
  _swigc__p_ElementTransformer,
  _swigc__p_Event,
  _swigc__p_EventAssignment,
  _swigc__p_ExpectedAttributes,
  _swigc__p_ExtendedMathType_t,
  _swigc__p_FormulaUnitsData,
  _swigc__p_FunctionDefinition,
  _swigc__p_ISBMLExtensionNamespaces,
  _swigc__p_IdList,
  _swigc__p_IdentifierTransformer,
  _swigc__p_InitialAssignment,
  _swigc__p_KineticLaw,
  _swigc__p_L3ParserGrammarLineType_t,
  _swigc__p_L3ParserSettings,
  _swigc__p_List,
  _swigc__p_ListNode,
  _swigc__p_ListOf,
  _swigc__p_ListOfCompartmentTypes,
  _swigc__p_ListOfCompartments,
  _swigc__p_ListOfConstraints,
  _swigc__p_ListOfEventAssignments,
  _swigc__p_ListOfEvents,
  _swigc__p_ListOfFunctionDefinitions,
  _swigc__p_ListOfInitialAssignments,
  _swigc__p_ListOfLocalParameters,
  _swigc__p_ListOfParameters,
  _swigc__p_ListOfReactions,
  _swigc__p_ListOfRules,
  _swigc__p_ListOfSpecies,
  _swigc__p_ListOfSpeciesReferences,
  _swigc__p_ListOfSpeciesTypes,
  _swigc__p_ListOfUnitDefinitions,
  _swigc__p_ListOfUnits,
  _swigc__p_ListWrapperT_ASTNode_t,
  _swigc__p_ListWrapperT_CVTerm_t,
  _swigc__p_ListWrapperT_Date_t,
  _swigc__p_ListWrapperT_ModelCreator_t,
  _swigc__p_ListWrapperT_SBMLNamespaces_t,
  _swigc__p_ListWrapperT_SBase_t,
  _swigc__p_LocalParameter,
  _swigc__p_MathFilter,
  _swigc__p_Model,
  _swigc__p_ModelCreator,
  _swigc__p_ModelHistory,
  _swigc__p_ModelQualifierType_t,
  _swigc__p_ModifierSpeciesReference,
  _swigc__p_OperationReturnValues_t,
  _swigc__p_Parameter,
  _swigc__p_ParseLogType_t,
  _swigc__p_Priority,
  _swigc__p_QualifierType_t,
  _swigc__p_RDFAnnotationParser,
  _swigc__p_RateRule,
  _swigc__p_Reaction,
  _swigc__p_Rule,
  _swigc__p_RuleType_t,
  _swigc__p_SBMLConstructorException,
  _swigc__p_SBMLConverter,
  _swigc__p_SBMLConverterRegistry,
  _swigc__p_SBMLDocument,
  _swigc__p_SBMLDocumentPlugin,
  _swigc__p_SBMLError,
  _swigc__p_SBMLErrorCategory_t,
  _swigc__p_SBMLErrorCode_t,
  _swigc__p_SBMLErrorLog,
  _swigc__p_SBMLErrorSeverity_t,
  _swigc__p_SBMLExtension,
  _swigc__p_SBMLExtensionException,
  _swigc__p_SBMLExtensionRegistry,
  _swigc__p_SBMLExternalValidator,
  _swigc__p_SBMLFunctionDefinitionConverter,
  _swigc__p_SBMLIdConverter,
  _swigc__p_SBMLInferUnitsConverter,
  _swigc__p_SBMLInitialAssignmentConverter,
  _swigc__p_SBMLLevel1Version1Converter,
  _swigc__p_SBMLLevelVersionConverter,
  _swigc__p_SBMLLocalParameterConverter,
  _swigc__p_SBMLNamespaces,
  _swigc__p_SBMLReactionConverter,
  _swigc__p_SBMLReader,
  _swigc__p_SBMLRuleConverter,
  _swigc__p_SBMLStripPackageConverter,
  _swigc__p_SBMLTransforms,
  _swigc__p_SBMLTypeCode_t,
  _swigc__p_SBMLUnitsConverter,
  _swigc__p_SBMLValidator,
  _swigc__p_SBMLWriter,
  _swigc__p_SBO,
  _swigc__p_SBase,
  _swigc__p_SBaseExtensionPoint,
  _swigc__p_SBasePlugin,
  _swigc__p_SBasePluginCreatorBase,
  _swigc__p_SimpleSpeciesReference,
  _swigc__p_Species,
  _swigc__p_SpeciesReference,
  _swigc__p_SpeciesType,
  _swigc__p_StoichiometryMath,
  _swigc__p_StringBuffer_t,
  _swigc__p_SupportedPackageURIList,
  _swigc__p_SupportedPackageURIListIter,
  _swigc__p_SyntaxChecker,
  _swigc__p_Trigger,
  _swigc__p_Unit,
  _swigc__p_UnitDefinition,
  _swigc__p_UnitFormulaFormatter,
  _swigc__p_UnitKind_t,
  _swigc__p_XMLAttributes,
  _swigc__p_XMLConstructorException,
  _swigc__p_XMLError,
  _swigc__p_XMLErrorCategory_t,
  _swigc__p_XMLErrorCode_t,
  _swigc__p_XMLErrorLog,
  _swigc__p_XMLErrorSeverityOverride_t,
  _swigc__p_XMLErrorSeverity_t,
  _swigc__p_XMLInputStream,
  _swigc__p_XMLNamespaces,
  _swigc__p_XMLNode,
  _swigc__p_XMLOutputFileStream,
  _swigc__p_XMLOutputStream,
  _swigc__p_XMLOutputStringStream,
  _swigc__p_XMLOwningOutputFileStream,
  _swigc__p_XMLOwningOutputStringStream,
  _swigc__p_XMLToken,
  _swigc__p_XMLTriple,
  _swigc__p_allocator_type,
  _swigc__p_char,
  _swigc__p_char_type,
  _swigc__p_const_iterator,
  _swigc__p_const_reference,
  _swigc__p_difference_type,
  _swigc__p_int_type,
  _swigc__p_iterator,
  _swigc__p_off_type,
  _swigc__p_p_PyObject,
  _swigc__p_pos_type,
  _swigc__p_reference,
  _swigc__p_size_type,
  _swigc__p_state_type,
  _swigc__p_std__basic_iosT_char_std__char_traitsT_char_t_t,
  _swigc__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_std__basic_streambufT_char_std__char_traitsT_char_t_t,
  _swigc__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t__iterator,
  _swigc__p_std__invalid_argument,
  _swigc__p_std__ios_base__openmode,
  _swigc__p_std__multimapT_int_int_t,
  _swigc__p_std__multimapT_int_int_t__iterator,
  _swigc__p_std__pairT_std__multimapT_int_int_t__iterator_std__multimapT_int_int_t__iterator_t,
  _swigc__p_std__stringstream,
  _swigc__p_std__vectorT_ASTBasePlugin_p_t,
  _swigc__p_std__vectorT_XMLError_p_t,
  _swigc__p_std__vectorT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t,
  _swigc__p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t,
  _swigc__p_std__vectorT_std__pairT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_ASTNode_p_t_t__iterator,
  _swigc__p_std__vectorT_unsigned_int_t,
  _swigc__p_swig__SwigPyIterator,
  _swigc__p_value_type,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
  
  /* -----------------------------------------------------------------------------
   * global variable support code.
   * ----------------------------------------------------------------------------- */
  
  typedef struct swig_globalvar {
    char       *name;                  /* Name of global variable */
    PyObject *(*get_attr)(void);       /* Return the current value */
    int       (*set_attr)(PyObject *); /* Set the value */
    struct swig_globalvar *next;
  } swig_globalvar;
  
  typedef struct swig_varlinkobject {
    PyObject_HEAD
    swig_globalvar *vars;
  } swig_varlinkobject;
  
  SWIGINTERN PyObject *
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
    return PyUnicode_InternFromString("<Swig global variables>");
#else
    return PyString_FromString("<Swig global variables>");
#endif
  }
  
  SWIGINTERN PyObject *
  swig_varlink_str(swig_varlinkobject *v) {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *str = PyUnicode_InternFromString("(");
    PyObject *tail;
    PyObject *joined;
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      tail = PyUnicode_FromString(var->name);
      joined = PyUnicode_Concat(str, tail);
      Py_DecRef(str);
      Py_DecRef(tail);
      str = joined;
      if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        Py_DecRef(str);
        Py_DecRef(tail);
        str = joined;
      }
    }
    tail = PyUnicode_InternFromString(")");
    joined = PyUnicode_Concat(str, tail);
    Py_DecRef(str);
    Py_DecRef(tail);
    str = joined;
#else
    PyObject *str = PyString_FromString("(");
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
    }
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
    return str;
  }
  
  SWIGINTERN void
  swig_varlink_dealloc(swig_varlinkobject *v) {
    swig_globalvar *var = v->vars;
    while (var) {
      swig_globalvar *n = var->next;
      free(var->name);
      free(var);
      var = n;
    }
  }
  
  SWIGINTERN PyObject *
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
    PyObject *res = NULL;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->get_attr)();
        break;
      }
      var = var->next;
    }
    if (res == NULL && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN int
  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
    int res = 1;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->set_attr)(p);
        break;
      }
      var = var->next;
    }
    if (res == 1 && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN PyTypeObject*
  swig_varlink_type(void) {
    static char varlink__doc__[] = "Swig var link object";
    static PyTypeObject varlink_type;
    static int type_init = 0;
    if (!type_init) {
      const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
        PyVarObject_HEAD_INIT(NULL, 0)
#else
        PyObject_HEAD_INIT(NULL)
        0,                                  /* ob_size */
#endif
        "swigvarlink",                      /* tp_name */
        sizeof(swig_varlinkobject),         /* tp_basicsize */
        0,                                  /* tp_itemsize */
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
        0,                                  /* tp_print */
        (getattrfunc) swig_varlink_getattr, /* tp_getattr */
        (setattrfunc) swig_varlink_setattr, /* tp_setattr */
        0,                                  /* tp_compare */
        (reprfunc) swig_varlink_repr,       /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                                  /* tp_call */
        (reprfunc) swig_varlink_str,        /* tp_str */
        0,                                  /* tp_getattro */
        0,                                  /* tp_setattro */
        0,                                  /* tp_as_buffer */
        0,                                  /* tp_flags */
        varlink__doc__,                     /* tp_doc */
        0,                                  /* tp_traverse */
        0,                                  /* tp_clear */
        0,                                  /* tp_richcompare */
        0,                                  /* tp_weaklistoffset */
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
        0,                                  /* tp_del */
        0,                                  /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
        0,                                  /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
        0,                                  /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
        0,                                  /* tp_print */
#endif
#ifdef COUNT_ALLOCS
        0,                                  /* tp_allocs */
        0,                                  /* tp_frees */
        0,                                  /* tp_maxalloc */
        0,                                  /* tp_prev */
        0                                   /* tp_next */
#endif
      };
      varlink_type = tmp;
      type_init = 1;
      if (PyType_Ready(&varlink_type) < 0)
      return NULL;
    }
    return &varlink_type;
  }
  
  /* Create a variable linking object for use later */
  SWIGINTERN PyObject *
  SWIG_Python_newvarlink(void) {
    swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
    if (result) {
      result->vars = 0;
    }
    return ((PyObject*) result);
  }
  
  SWIGINTERN void 
  SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
    swig_varlinkobject *v = (swig_varlinkobject *) p;
    swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
    if (gv) {
      size_t size = strlen(name)+1;
      gv->name = (char *)malloc(size);
      if (gv->name) {
        memcpy(gv->name, name, size);
        gv->get_attr = get_attr;
        gv->set_attr = set_attr;
        gv->next = v->vars;
      }
    }
    v->vars = gv;
  }
  
  SWIGINTERN PyObject *
  SWIG_globals(void) {
    static PyObject *globals = 0;
    if (!globals) {
      globals = SWIG_newvarlink();
    }
    return globals;
  }
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------*/
  /* Fix SwigMethods to carry the callback ptrs when needed */
  /* -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods,
    swig_const_info *const_table,
    swig_type_info **types,
    swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              memcpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              memcpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
  /* -----------------------------------------------------------------------------
   * Method creation and docstring support functions
   * ----------------------------------------------------------------------------- */
  
  /* -----------------------------------------------------------------------------
   * Function to find the method definition with the correct docstring for the
   * proxy module as opposed to the low-level API
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
    /* Find the function in the modified method table */
    size_t offset = 0;
    int found = 0;
    while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
      if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
        found = 1;
        break;
      }
      offset++;
    }
    /* Use the copy with the modified docstring if available */
    return found ? &SwigMethods_proxydocs[offset] : NULL;
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyInstanceMethod_New() used in Python 3
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
#if PY_VERSION_HEX >= 0x03000000
    return PyInstanceMethod_New(func);
#else
    return PyMethod_New(func, NULL, NULL);
#endif
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyStaticMethod_New()
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
    return PyStaticMethod_New(func);
  }
  
#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md, *globals;
  
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    SwigPyObject_own,
    SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType();
  assert(metatype);
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
  SwigPyObject_type();
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule(SWIG_name, SwigMethods);
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  globals = SWIG_globals();
  if (!globals) {
    PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  PyDict_SetItemString(md, "cvar", globals);
  Py_DECREF(globals);
  SWIG_addvarlink(globals, "string_npos", Swig_var_string_npos_get, Swig_var_string_npos_set);
  SWIG_addvarlink(globals, "cout", Swig_var_cout_get, Swig_var_cout_set);
  SWIG_addvarlink(globals, "cerr", Swig_var_cerr_get, Swig_var_cerr_set);
  SWIG_addvarlink(globals, "clog", Swig_var_clog_get, Swig_var_clog_set);
  SWIG_Python_SetConstant(d, "LIBSBML_DOTTED_VERSION",SWIG_FromCharPtr("5.19.0"));
  SWIG_Python_SetConstant(d, "LIBSBML_VERSION",SWIG_From_int(static_cast< int >(51900)));
  SWIG_Python_SetConstant(d, "LIBSBML_VERSION_STRING",SWIG_FromCharPtr("51900"));
  SWIG_Python_SetConstant(d, "LIBSBML_OPERATION_SUCCESS",SWIG_From_int(static_cast< int >(LIBSBML_OPERATION_SUCCESS)));
  SWIG_Python_SetConstant(d, "LIBSBML_INDEX_EXCEEDS_SIZE",SWIG_From_int(static_cast< int >(LIBSBML_INDEX_EXCEEDS_SIZE)));
  SWIG_Python_SetConstant(d, "LIBSBML_UNEXPECTED_ATTRIBUTE",SWIG_From_int(static_cast< int >(LIBSBML_UNEXPECTED_ATTRIBUTE)));
  SWIG_Python_SetConstant(d, "LIBSBML_OPERATION_FAILED",SWIG_From_int(static_cast< int >(LIBSBML_OPERATION_FAILED)));
  SWIG_Python_SetConstant(d, "LIBSBML_INVALID_ATTRIBUTE_VALUE",SWIG_From_int(static_cast< int >(LIBSBML_INVALID_ATTRIBUTE_VALUE)));
  SWIG_Python_SetConstant(d, "LIBSBML_INVALID_OBJECT",SWIG_From_int(static_cast< int >(LIBSBML_INVALID_OBJECT)));
  SWIG_Python_SetConstant(d, "LIBSBML_DUPLICATE_OBJECT_ID",SWIG_From_int(static_cast< int >(LIBSBML_DUPLICATE_OBJECT_ID)));
  SWIG_Python_SetConstant(d, "LIBSBML_LEVEL_MISMATCH",SWIG_From_int(static_cast< int >(LIBSBML_LEVEL_MISMATCH)));
  SWIG_Python_SetConstant(d, "LIBSBML_VERSION_MISMATCH",SWIG_From_int(static_cast< int >(LIBSBML_VERSION_MISMATCH)));
  SWIG_Python_SetConstant(d, "LIBSBML_INVALID_XML_OPERATION",SWIG_From_int(static_cast< int >(LIBSBML_INVALID_XML_OPERATION)));
  SWIG_Python_SetConstant(d, "LIBSBML_NAMESPACES_MISMATCH",SWIG_From_int(static_cast< int >(LIBSBML_NAMESPACES_MISMATCH)));
  SWIG_Python_SetConstant(d, "LIBSBML_DUPLICATE_ANNOTATION_NS",SWIG_From_int(static_cast< int >(LIBSBML_DUPLICATE_ANNOTATION_NS)));
  SWIG_Python_SetConstant(d, "LIBSBML_ANNOTATION_NAME_NOT_FOUND",SWIG_From_int(static_cast< int >(LIBSBML_ANNOTATION_NAME_NOT_FOUND)));
  SWIG_Python_SetConstant(d, "LIBSBML_ANNOTATION_NS_NOT_FOUND",SWIG_From_int(static_cast< int >(LIBSBML_ANNOTATION_NS_NOT_FOUND)));
  SWIG_Python_SetConstant(d, "LIBSBML_MISSING_METAID",SWIG_From_int(static_cast< int >(LIBSBML_MISSING_METAID)));
  SWIG_Python_SetConstant(d, "LIBSBML_DEPRECATED_ATTRIBUTE",SWIG_From_int(static_cast< int >(LIBSBML_DEPRECATED_ATTRIBUTE)));
  SWIG_Python_SetConstant(d, "LIBSBML_USE_ID_ATTRIBUTE_FUNCTION",SWIG_From_int(static_cast< int >(LIBSBML_USE_ID_ATTRIBUTE_FUNCTION)));
  SWIG_Python_SetConstant(d, "LIBSBML_PKG_VERSION_MISMATCH",SWIG_From_int(static_cast< int >(LIBSBML_PKG_VERSION_MISMATCH)));
  SWIG_Python_SetConstant(d, "LIBSBML_PKG_UNKNOWN",SWIG_From_int(static_cast< int >(LIBSBML_PKG_UNKNOWN)));
  SWIG_Python_SetConstant(d, "LIBSBML_PKG_UNKNOWN_VERSION",SWIG_From_int(static_cast< int >(LIBSBML_PKG_UNKNOWN_VERSION)));
  SWIG_Python_SetConstant(d, "LIBSBML_PKG_DISABLED",SWIG_From_int(static_cast< int >(LIBSBML_PKG_DISABLED)));
  SWIG_Python_SetConstant(d, "LIBSBML_PKG_CONFLICTED_VERSION",SWIG_From_int(static_cast< int >(LIBSBML_PKG_CONFLICTED_VERSION)));
  SWIG_Python_SetConstant(d, "LIBSBML_PKG_CONFLICT",SWIG_From_int(static_cast< int >(LIBSBML_PKG_CONFLICT)));
  SWIG_Python_SetConstant(d, "LIBSBML_CONV_INVALID_TARGET_NAMESPACE",SWIG_From_int(static_cast< int >(LIBSBML_CONV_INVALID_TARGET_NAMESPACE)));
  SWIG_Python_SetConstant(d, "LIBSBML_CONV_PKG_CONVERSION_NOT_AVAILABLE",SWIG_From_int(static_cast< int >(LIBSBML_CONV_PKG_CONVERSION_NOT_AVAILABLE)));
  SWIG_Python_SetConstant(d, "LIBSBML_CONV_INVALID_SRC_DOCUMENT",SWIG_From_int(static_cast< int >(LIBSBML_CONV_INVALID_SRC_DOCUMENT)));
  SWIG_Python_SetConstant(d, "LIBSBML_CONV_CONVERSION_NOT_AVAILABLE",SWIG_From_int(static_cast< int >(LIBSBML_CONV_CONVERSION_NOT_AVAILABLE)));
  SWIG_Python_SetConstant(d, "LIBSBML_CONV_PKG_CONSIDERED_UNKNOWN",SWIG_From_int(static_cast< int >(LIBSBML_CONV_PKG_CONSIDERED_UNKNOWN)));
  SWIG_Python_SetConstant(d, "SBML_UNKNOWN",SWIG_From_int(static_cast< int >(SBML_UNKNOWN)));
  SWIG_Python_SetConstant(d, "SBML_COMPARTMENT",SWIG_From_int(static_cast< int >(SBML_COMPARTMENT)));
  SWIG_Python_SetConstant(d, "SBML_COMPARTMENT_TYPE",SWIG_From_int(static_cast< int >(SBML_COMPARTMENT_TYPE)));
  SWIG_Python_SetConstant(d, "SBML_CONSTRAINT",SWIG_From_int(static_cast< int >(SBML_CONSTRAINT)));
  SWIG_Python_SetConstant(d, "SBML_DOCUMENT",SWIG_From_int(static_cast< int >(SBML_DOCUMENT)));
  SWIG_Python_SetConstant(d, "SBML_EVENT",SWIG_From_int(static_cast< int >(SBML_EVENT)));
  SWIG_Python_SetConstant(d, "SBML_EVENT_ASSIGNMENT",SWIG_From_int(static_cast< int >(SBML_EVENT_ASSIGNMENT)));
  SWIG_Python_SetConstant(d, "SBML_FUNCTION_DEFINITION",SWIG_From_int(static_cast< int >(SBML_FUNCTION_DEFINITION)));
  SWIG_Python_SetConstant(d, "SBML_INITIAL_ASSIGNMENT",SWIG_From_int(static_cast< int >(SBML_INITIAL_ASSIGNMENT)));
  SWIG_Python_SetConstant(d, "SBML_KINETIC_LAW",SWIG_From_int(static_cast< int >(SBML_KINETIC_LAW)));
  SWIG_Python_SetConstant(d, "SBML_LIST_OF",SWIG_From_int(static_cast< int >(SBML_LIST_OF)));
  SWIG_Python_SetConstant(d, "SBML_MODEL",SWIG_From_int(static_cast< int >(SBML_MODEL)));
  SWIG_Python_SetConstant(d, "SBML_PARAMETER",SWIG_From_int(static_cast< int >(SBML_PARAMETER)));
  SWIG_Python_SetConstant(d, "SBML_REACTION",SWIG_From_int(static_cast< int >(SBML_REACTION)));
  SWIG_Python_SetConstant(d, "SBML_RULE",SWIG_From_int(static_cast< int >(SBML_RULE)));
  SWIG_Python_SetConstant(d, "SBML_SPECIES",SWIG_From_int(static_cast< int >(SBML_SPECIES)));
  SWIG_Python_SetConstant(d, "SBML_SPECIES_REFERENCE",SWIG_From_int(static_cast< int >(SBML_SPECIES_REFERENCE)));
  SWIG_Python_SetConstant(d, "SBML_SPECIES_TYPE",SWIG_From_int(static_cast< int >(SBML_SPECIES_TYPE)));
  SWIG_Python_SetConstant(d, "SBML_MODIFIER_SPECIES_REFERENCE",SWIG_From_int(static_cast< int >(SBML_MODIFIER_SPECIES_REFERENCE)));
  SWIG_Python_SetConstant(d, "SBML_UNIT_DEFINITION",SWIG_From_int(static_cast< int >(SBML_UNIT_DEFINITION)));
  SWIG_Python_SetConstant(d, "SBML_UNIT",SWIG_From_int(static_cast< int >(SBML_UNIT)));
  SWIG_Python_SetConstant(d, "SBML_ALGEBRAIC_RULE",SWIG_From_int(static_cast< int >(SBML_ALGEBRAIC_RULE)));
  SWIG_Python_SetConstant(d, "SBML_ASSIGNMENT_RULE",SWIG_From_int(static_cast< int >(SBML_ASSIGNMENT_RULE)));
  SWIG_Python_SetConstant(d, "SBML_RATE_RULE",SWIG_From_int(static_cast< int >(SBML_RATE_RULE)));
  SWIG_Python_SetConstant(d, "SBML_SPECIES_CONCENTRATION_RULE",SWIG_From_int(static_cast< int >(SBML_SPECIES_CONCENTRATION_RULE)));
  SWIG_Python_SetConstant(d, "SBML_COMPARTMENT_VOLUME_RULE",SWIG_From_int(static_cast< int >(SBML_COMPARTMENT_VOLUME_RULE)));
  SWIG_Python_SetConstant(d, "SBML_PARAMETER_RULE",SWIG_From_int(static_cast< int >(SBML_PARAMETER_RULE)));
  SWIG_Python_SetConstant(d, "SBML_TRIGGER",SWIG_From_int(static_cast< int >(SBML_TRIGGER)));
  SWIG_Python_SetConstant(d, "SBML_DELAY",SWIG_From_int(static_cast< int >(SBML_DELAY)));
  SWIG_Python_SetConstant(d, "SBML_STOICHIOMETRY_MATH",SWIG_From_int(static_cast< int >(SBML_STOICHIOMETRY_MATH)));
  SWIG_Python_SetConstant(d, "SBML_LOCAL_PARAMETER",SWIG_From_int(static_cast< int >(SBML_LOCAL_PARAMETER)));
  SWIG_Python_SetConstant(d, "SBML_PRIORITY",SWIG_From_int(static_cast< int >(SBML_PRIORITY)));
  SWIG_Python_SetConstant(d, "SBML_GENERIC_SBASE",SWIG_From_int(static_cast< int >(SBML_GENERIC_SBASE)));
  SWIG_Python_SetConstant(d, "IdCheckON",SWIG_From_int(static_cast< int >(0x01)));
  SWIG_Python_SetConstant(d, "IdCheckOFF",SWIG_From_int(static_cast< int >(0xfe)));
  SWIG_Python_SetConstant(d, "SBMLCheckON",SWIG_From_int(static_cast< int >(0x02)));
  SWIG_Python_SetConstant(d, "SBMLCheckOFF",SWIG_From_int(static_cast< int >(0xfd)));
  SWIG_Python_SetConstant(d, "SBOCheckON",SWIG_From_int(static_cast< int >(0x04)));
  SWIG_Python_SetConstant(d, "SBOCheckOFF",SWIG_From_int(static_cast< int >(0xfb)));
  SWIG_Python_SetConstant(d, "MathCheckON",SWIG_From_int(static_cast< int >(0x08)));
  SWIG_Python_SetConstant(d, "MathCheckOFF",SWIG_From_int(static_cast< int >(0xf7)));
  SWIG_Python_SetConstant(d, "UnitsCheckON",SWIG_From_int(static_cast< int >(0x10)));
  SWIG_Python_SetConstant(d, "UnitsCheckOFF",SWIG_From_int(static_cast< int >(0xef)));
  SWIG_Python_SetConstant(d, "OverdeterCheckON",SWIG_From_int(static_cast< int >(0x20)));
  SWIG_Python_SetConstant(d, "OverdeterCheckOFF",SWIG_From_int(static_cast< int >(0xdf)));
  SWIG_Python_SetConstant(d, "PracticeCheckON",SWIG_From_int(static_cast< int >(0x40)));
  SWIG_Python_SetConstant(d, "PracticeCheckOFF",SWIG_From_int(static_cast< int >(0xbf)));
  SWIG_Python_SetConstant(d, "AllChecksON",SWIG_From_int(static_cast< int >(0x7f)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_AMPERE",SWIG_From_int(static_cast< int >(UNIT_KIND_AMPERE)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_AVOGADRO",SWIG_From_int(static_cast< int >(UNIT_KIND_AVOGADRO)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_BECQUEREL",SWIG_From_int(static_cast< int >(UNIT_KIND_BECQUEREL)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_CANDELA",SWIG_From_int(static_cast< int >(UNIT_KIND_CANDELA)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_CELSIUS",SWIG_From_int(static_cast< int >(UNIT_KIND_CELSIUS)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_COULOMB",SWIG_From_int(static_cast< int >(UNIT_KIND_COULOMB)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_DIMENSIONLESS",SWIG_From_int(static_cast< int >(UNIT_KIND_DIMENSIONLESS)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_FARAD",SWIG_From_int(static_cast< int >(UNIT_KIND_FARAD)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_GRAM",SWIG_From_int(static_cast< int >(UNIT_KIND_GRAM)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_GRAY",SWIG_From_int(static_cast< int >(UNIT_KIND_GRAY)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_HENRY",SWIG_From_int(static_cast< int >(UNIT_KIND_HENRY)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_HERTZ",SWIG_From_int(static_cast< int >(UNIT_KIND_HERTZ)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_ITEM",SWIG_From_int(static_cast< int >(UNIT_KIND_ITEM)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_JOULE",SWIG_From_int(static_cast< int >(UNIT_KIND_JOULE)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_KATAL",SWIG_From_int(static_cast< int >(UNIT_KIND_KATAL)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_KELVIN",SWIG_From_int(static_cast< int >(UNIT_KIND_KELVIN)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_KILOGRAM",SWIG_From_int(static_cast< int >(UNIT_KIND_KILOGRAM)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_LITER",SWIG_From_int(static_cast< int >(UNIT_KIND_LITER)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_LITRE",SWIG_From_int(static_cast< int >(UNIT_KIND_LITRE)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_LUMEN",SWIG_From_int(static_cast< int >(UNIT_KIND_LUMEN)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_LUX",SWIG_From_int(static_cast< int >(UNIT_KIND_LUX)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_METER",SWIG_From_int(static_cast< int >(UNIT_KIND_METER)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_METRE",SWIG_From_int(static_cast< int >(UNIT_KIND_METRE)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_MOLE",SWIG_From_int(static_cast< int >(UNIT_KIND_MOLE)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_NEWTON",SWIG_From_int(static_cast< int >(UNIT_KIND_NEWTON)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_OHM",SWIG_From_int(static_cast< int >(UNIT_KIND_OHM)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_PASCAL",SWIG_From_int(static_cast< int >(UNIT_KIND_PASCAL)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_RADIAN",SWIG_From_int(static_cast< int >(UNIT_KIND_RADIAN)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_SECOND",SWIG_From_int(static_cast< int >(UNIT_KIND_SECOND)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_SIEMENS",SWIG_From_int(static_cast< int >(UNIT_KIND_SIEMENS)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_SIEVERT",SWIG_From_int(static_cast< int >(UNIT_KIND_SIEVERT)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_STERADIAN",SWIG_From_int(static_cast< int >(UNIT_KIND_STERADIAN)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_TESLA",SWIG_From_int(static_cast< int >(UNIT_KIND_TESLA)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_VOLT",SWIG_From_int(static_cast< int >(UNIT_KIND_VOLT)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_WATT",SWIG_From_int(static_cast< int >(UNIT_KIND_WATT)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_WEBER",SWIG_From_int(static_cast< int >(UNIT_KIND_WEBER)));
  SWIG_Python_SetConstant(d, "UNIT_KIND_INVALID",SWIG_From_int(static_cast< int >(UNIT_KIND_INVALID)));
  SWIG_Python_SetConstant(d, "RULE_TYPE_RATE",SWIG_From_int(static_cast< int >(RULE_TYPE_RATE)));
  SWIG_Python_SetConstant(d, "RULE_TYPE_SCALAR",SWIG_From_int(static_cast< int >(RULE_TYPE_SCALAR)));
  SWIG_Python_SetConstant(d, "RULE_TYPE_INVALID",SWIG_From_int(static_cast< int >(RULE_TYPE_INVALID)));
  SWIG_Python_SetConstant(d, "CNV_TYPE_BOOL",SWIG_From_int(static_cast< int >(CNV_TYPE_BOOL)));
  SWIG_Python_SetConstant(d, "CNV_TYPE_DOUBLE",SWIG_From_int(static_cast< int >(CNV_TYPE_DOUBLE)));
  SWIG_Python_SetConstant(d, "CNV_TYPE_INT",SWIG_From_int(static_cast< int >(CNV_TYPE_INT)));
  SWIG_Python_SetConstant(d, "CNV_TYPE_SINGLE",SWIG_From_int(static_cast< int >(CNV_TYPE_SINGLE)));
  SWIG_Python_SetConstant(d, "CNV_TYPE_STRING",SWIG_From_int(static_cast< int >(CNV_TYPE_STRING)));
  SWIG_Python_SetConstant(d, "XMLUnknownError",SWIG_From_int(static_cast< int >(XMLUnknownError)));
  SWIG_Python_SetConstant(d, "XMLOutOfMemory",SWIG_From_int(static_cast< int >(XMLOutOfMemory)));
  SWIG_Python_SetConstant(d, "XMLFileUnreadable",SWIG_From_int(static_cast< int >(XMLFileUnreadable)));
  SWIG_Python_SetConstant(d, "XMLFileUnwritable",SWIG_From_int(static_cast< int >(XMLFileUnwritable)));
  SWIG_Python_SetConstant(d, "XMLFileOperationError",SWIG_From_int(static_cast< int >(XMLFileOperationError)));
  SWIG_Python_SetConstant(d, "XMLNetworkAccessError",SWIG_From_int(static_cast< int >(XMLNetworkAccessError)));
  SWIG_Python_SetConstant(d, "InternalXMLParserError",SWIG_From_int(static_cast< int >(InternalXMLParserError)));
  SWIG_Python_SetConstant(d, "UnrecognizedXMLParserCode",SWIG_From_int(static_cast< int >(UnrecognizedXMLParserCode)));
  SWIG_Python_SetConstant(d, "XMLTranscoderError",SWIG_From_int(static_cast< int >(XMLTranscoderError)));
  SWIG_Python_SetConstant(d, "MissingXMLDecl",SWIG_From_int(static_cast< int >(MissingXMLDecl)));
  SWIG_Python_SetConstant(d, "MissingXMLEncoding",SWIG_From_int(static_cast< int >(MissingXMLEncoding)));
  SWIG_Python_SetConstant(d, "BadXMLDecl",SWIG_From_int(static_cast< int >(BadXMLDecl)));
  SWIG_Python_SetConstant(d, "BadXMLDOCTYPE",SWIG_From_int(static_cast< int >(BadXMLDOCTYPE)));
  SWIG_Python_SetConstant(d, "InvalidCharInXML",SWIG_From_int(static_cast< int >(InvalidCharInXML)));
  SWIG_Python_SetConstant(d, "BadlyFormedXML",SWIG_From_int(static_cast< int >(BadlyFormedXML)));
  SWIG_Python_SetConstant(d, "UnclosedXMLToken",SWIG_From_int(static_cast< int >(UnclosedXMLToken)));
  SWIG_Python_SetConstant(d, "InvalidXMLConstruct",SWIG_From_int(static_cast< int >(InvalidXMLConstruct)));
  SWIG_Python_SetConstant(d, "XMLTagMismatch",SWIG_From_int(static_cast< int >(XMLTagMismatch)));
  SWIG_Python_SetConstant(d, "DuplicateXMLAttribute",SWIG_From_int(static_cast< int >(DuplicateXMLAttribute)));
  SWIG_Python_SetConstant(d, "UndefinedXMLEntity",SWIG_From_int(static_cast< int >(UndefinedXMLEntity)));
  SWIG_Python_SetConstant(d, "BadProcessingInstruction",SWIG_From_int(static_cast< int >(BadProcessingInstruction)));
  SWIG_Python_SetConstant(d, "BadXMLPrefix",SWIG_From_int(static_cast< int >(BadXMLPrefix)));
  SWIG_Python_SetConstant(d, "BadXMLPrefixValue",SWIG_From_int(static_cast< int >(BadXMLPrefixValue)));
  SWIG_Python_SetConstant(d, "MissingXMLRequiredAttribute",SWIG_From_int(static_cast< int >(MissingXMLRequiredAttribute)));
  SWIG_Python_SetConstant(d, "XMLAttributeTypeMismatch",SWIG_From_int(static_cast< int >(XMLAttributeTypeMismatch)));
  SWIG_Python_SetConstant(d, "XMLBadUTF8Content",SWIG_From_int(static_cast< int >(XMLBadUTF8Content)));
  SWIG_Python_SetConstant(d, "MissingXMLAttributeValue",SWIG_From_int(static_cast< int >(MissingXMLAttributeValue)));
  SWIG_Python_SetConstant(d, "BadXMLAttributeValue",SWIG_From_int(static_cast< int >(BadXMLAttributeValue)));
  SWIG_Python_SetConstant(d, "BadXMLAttribute",SWIG_From_int(static_cast< int >(BadXMLAttribute)));
  SWIG_Python_SetConstant(d, "UnrecognizedXMLElement",SWIG_From_int(static_cast< int >(UnrecognizedXMLElement)));
  SWIG_Python_SetConstant(d, "BadXMLComment",SWIG_From_int(static_cast< int >(BadXMLComment)));
  SWIG_Python_SetConstant(d, "BadXMLDeclLocation",SWIG_From_int(static_cast< int >(BadXMLDeclLocation)));
  SWIG_Python_SetConstant(d, "XMLUnexpectedEOF",SWIG_From_int(static_cast< int >(XMLUnexpectedEOF)));
  SWIG_Python_SetConstant(d, "BadXMLIDValue",SWIG_From_int(static_cast< int >(BadXMLIDValue)));
  SWIG_Python_SetConstant(d, "BadXMLIDRef",SWIG_From_int(static_cast< int >(BadXMLIDRef)));
  SWIG_Python_SetConstant(d, "UninterpretableXMLContent",SWIG_From_int(static_cast< int >(UninterpretableXMLContent)));
  SWIG_Python_SetConstant(d, "BadXMLDocumentStructure",SWIG_From_int(static_cast< int >(BadXMLDocumentStructure)));
  SWIG_Python_SetConstant(d, "InvalidAfterXMLContent",SWIG_From_int(static_cast< int >(InvalidAfterXMLContent)));
  SWIG_Python_SetConstant(d, "XMLExpectedQuotedString",SWIG_From_int(static_cast< int >(XMLExpectedQuotedString)));
  SWIG_Python_SetConstant(d, "XMLEmptyValueNotPermitted",SWIG_From_int(static_cast< int >(XMLEmptyValueNotPermitted)));
  SWIG_Python_SetConstant(d, "XMLBadNumber",SWIG_From_int(static_cast< int >(XMLBadNumber)));
  SWIG_Python_SetConstant(d, "XMLBadColon",SWIG_From_int(static_cast< int >(XMLBadColon)));
  SWIG_Python_SetConstant(d, "MissingXMLElements",SWIG_From_int(static_cast< int >(MissingXMLElements)));
  SWIG_Python_SetConstant(d, "XMLContentEmpty",SWIG_From_int(static_cast< int >(XMLContentEmpty)));
  SWIG_Python_SetConstant(d, "XMLErrorCodesUpperBound",SWIG_From_int(static_cast< int >(XMLErrorCodesUpperBound)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_INTERNAL",SWIG_From_int(static_cast< int >(LIBSBML_CAT_INTERNAL)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_SYSTEM",SWIG_From_int(static_cast< int >(LIBSBML_CAT_SYSTEM)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_XML",SWIG_From_int(static_cast< int >(LIBSBML_CAT_XML)));
  SWIG_Python_SetConstant(d, "LIBSBML_SEV_INFO",SWIG_From_int(static_cast< int >(LIBSBML_SEV_INFO)));
  SWIG_Python_SetConstant(d, "LIBSBML_SEV_WARNING",SWIG_From_int(static_cast< int >(LIBSBML_SEV_WARNING)));
  SWIG_Python_SetConstant(d, "LIBSBML_SEV_ERROR",SWIG_From_int(static_cast< int >(LIBSBML_SEV_ERROR)));
  SWIG_Python_SetConstant(d, "LIBSBML_SEV_FATAL",SWIG_From_int(static_cast< int >(LIBSBML_SEV_FATAL)));
  SWIG_Python_SetConstant(d, "LIBSBML_OVERRIDE_DISABLED",SWIG_From_int(static_cast< int >(LIBSBML_OVERRIDE_DISABLED)));
  SWIG_Python_SetConstant(d, "LIBSBML_OVERRIDE_DONT_LOG",SWIG_From_int(static_cast< int >(LIBSBML_OVERRIDE_DONT_LOG)));
  SWIG_Python_SetConstant(d, "LIBSBML_OVERRIDE_WARNING",SWIG_From_int(static_cast< int >(LIBSBML_OVERRIDE_WARNING)));
  SWIG_Python_SetConstant(d, "LIBSBML_OVERRIDE_ERROR",SWIG_From_int(static_cast< int >(LIBSBML_OVERRIDE_ERROR)));
  SWIG_Python_SetConstant(d, "UnknownError",SWIG_From_int(static_cast< int >(UnknownError)));
  SWIG_Python_SetConstant(d, "NotUTF8",SWIG_From_int(static_cast< int >(NotUTF8)));
  SWIG_Python_SetConstant(d, "UnrecognizedElement",SWIG_From_int(static_cast< int >(UnrecognizedElement)));
  SWIG_Python_SetConstant(d, "NotSchemaConformant",SWIG_From_int(static_cast< int >(NotSchemaConformant)));
  SWIG_Python_SetConstant(d, "L3NotSchemaConformant",SWIG_From_int(static_cast< int >(L3NotSchemaConformant)));
  SWIG_Python_SetConstant(d, "InvalidMathElement",SWIG_From_int(static_cast< int >(InvalidMathElement)));
  SWIG_Python_SetConstant(d, "DisallowedMathMLSymbol",SWIG_From_int(static_cast< int >(DisallowedMathMLSymbol)));
  SWIG_Python_SetConstant(d, "DisallowedMathMLEncodingUse",SWIG_From_int(static_cast< int >(DisallowedMathMLEncodingUse)));
  SWIG_Python_SetConstant(d, "DisallowedDefinitionURLUse",SWIG_From_int(static_cast< int >(DisallowedDefinitionURLUse)));
  SWIG_Python_SetConstant(d, "BadCsymbolDefinitionURLValue",SWIG_From_int(static_cast< int >(BadCsymbolDefinitionURLValue)));
  SWIG_Python_SetConstant(d, "DisallowedMathTypeAttributeUse",SWIG_From_int(static_cast< int >(DisallowedMathTypeAttributeUse)));
  SWIG_Python_SetConstant(d, "DisallowedMathTypeAttributeValue",SWIG_From_int(static_cast< int >(DisallowedMathTypeAttributeValue)));
  SWIG_Python_SetConstant(d, "LambdaOnlyAllowedInFunctionDef",SWIG_From_int(static_cast< int >(LambdaOnlyAllowedInFunctionDef)));
  SWIG_Python_SetConstant(d, "BooleanOpsNeedBooleanArgs",SWIG_From_int(static_cast< int >(BooleanOpsNeedBooleanArgs)));
  SWIG_Python_SetConstant(d, "NumericOpsNeedNumericArgs",SWIG_From_int(static_cast< int >(NumericOpsNeedNumericArgs)));
  SWIG_Python_SetConstant(d, "ArgsToEqNeedSameType",SWIG_From_int(static_cast< int >(ArgsToEqNeedSameType)));
  SWIG_Python_SetConstant(d, "PiecewiseNeedsConsistentTypes",SWIG_From_int(static_cast< int >(PiecewiseNeedsConsistentTypes)));
  SWIG_Python_SetConstant(d, "PieceNeedsBoolean",SWIG_From_int(static_cast< int >(PieceNeedsBoolean)));
  SWIG_Python_SetConstant(d, "ApplyCiMustBeUserFunction",SWIG_From_int(static_cast< int >(ApplyCiMustBeUserFunction)));
  SWIG_Python_SetConstant(d, "ApplyCiMustBeModelComponent",SWIG_From_int(static_cast< int >(ApplyCiMustBeModelComponent)));
  SWIG_Python_SetConstant(d, "KineticLawParametersAreLocalOnly",SWIG_From_int(static_cast< int >(KineticLawParametersAreLocalOnly)));
  SWIG_Python_SetConstant(d, "MathResultMustBeNumeric",SWIG_From_int(static_cast< int >(MathResultMustBeNumeric)));
  SWIG_Python_SetConstant(d, "OpsNeedCorrectNumberOfArgs",SWIG_From_int(static_cast< int >(OpsNeedCorrectNumberOfArgs)));
  SWIG_Python_SetConstant(d, "InvalidNoArgsPassedToFunctionDef",SWIG_From_int(static_cast< int >(InvalidNoArgsPassedToFunctionDef)));
  SWIG_Python_SetConstant(d, "DisallowedMathUnitsUse",SWIG_From_int(static_cast< int >(DisallowedMathUnitsUse)));
  SWIG_Python_SetConstant(d, "InvalidUnitsValue",SWIG_From_int(static_cast< int >(InvalidUnitsValue)));
  SWIG_Python_SetConstant(d, "CiCannotReference0DCompartment",SWIG_From_int(static_cast< int >(CiCannotReference0DCompartment)));
  SWIG_Python_SetConstant(d, "RateOfTargetMustBeCi",SWIG_From_int(static_cast< int >(RateOfTargetMustBeCi)));
  SWIG_Python_SetConstant(d, "RateOfTargetCannotBeAssigned",SWIG_From_int(static_cast< int >(RateOfTargetCannotBeAssigned)));
  SWIG_Python_SetConstant(d, "RateOfSpeciesTargetCompartmentNot",SWIG_From_int(static_cast< int >(RateOfSpeciesTargetCompartmentNot)));
  SWIG_Python_SetConstant(d, "DuplicateComponentId",SWIG_From_int(static_cast< int >(DuplicateComponentId)));
  SWIG_Python_SetConstant(d, "DuplicateUnitDefinitionId",SWIG_From_int(static_cast< int >(DuplicateUnitDefinitionId)));
  SWIG_Python_SetConstant(d, "DuplicateLocalParameterId",SWIG_From_int(static_cast< int >(DuplicateLocalParameterId)));
  SWIG_Python_SetConstant(d, "MultipleAssignmentOrRateRules",SWIG_From_int(static_cast< int >(MultipleAssignmentOrRateRules)));
  SWIG_Python_SetConstant(d, "MultipleEventAssignmentsForId",SWIG_From_int(static_cast< int >(MultipleEventAssignmentsForId)));
  SWIG_Python_SetConstant(d, "EventAndAssignmentRuleForId",SWIG_From_int(static_cast< int >(EventAndAssignmentRuleForId)));
  SWIG_Python_SetConstant(d, "DuplicateMetaId",SWIG_From_int(static_cast< int >(DuplicateMetaId)));
  SWIG_Python_SetConstant(d, "InvalidSBOTermSyntax",SWIG_From_int(static_cast< int >(InvalidSBOTermSyntax)));
  SWIG_Python_SetConstant(d, "InvalidMetaidSyntax",SWIG_From_int(static_cast< int >(InvalidMetaidSyntax)));
  SWIG_Python_SetConstant(d, "InvalidIdSyntax",SWIG_From_int(static_cast< int >(InvalidIdSyntax)));
  SWIG_Python_SetConstant(d, "InvalidUnitIdSyntax",SWIG_From_int(static_cast< int >(InvalidUnitIdSyntax)));
  SWIG_Python_SetConstant(d, "InvalidNameSyntax",SWIG_From_int(static_cast< int >(InvalidNameSyntax)));
  SWIG_Python_SetConstant(d, "DanglingUnitReference",SWIG_From_int(static_cast< int >(DanglingUnitReference)));
  SWIG_Python_SetConstant(d, "MissingAnnotationNamespace",SWIG_From_int(static_cast< int >(MissingAnnotationNamespace)));
  SWIG_Python_SetConstant(d, "DuplicateAnnotationNamespaces",SWIG_From_int(static_cast< int >(DuplicateAnnotationNamespaces)));
  SWIG_Python_SetConstant(d, "SBMLNamespaceInAnnotation",SWIG_From_int(static_cast< int >(SBMLNamespaceInAnnotation)));
  SWIG_Python_SetConstant(d, "MultipleAnnotations",SWIG_From_int(static_cast< int >(MultipleAnnotations)));
  SWIG_Python_SetConstant(d, "InconsistentArgUnits",SWIG_From_int(static_cast< int >(InconsistentArgUnits)));
  SWIG_Python_SetConstant(d, "InconsistentKineticLawUnitsL3",SWIG_From_int(static_cast< int >(InconsistentKineticLawUnitsL3)));
  SWIG_Python_SetConstant(d, "AssignRuleCompartmentMismatch",SWIG_From_int(static_cast< int >(AssignRuleCompartmentMismatch)));
  SWIG_Python_SetConstant(d, "AssignRuleSpeciesMismatch",SWIG_From_int(static_cast< int >(AssignRuleSpeciesMismatch)));
  SWIG_Python_SetConstant(d, "AssignRuleParameterMismatch",SWIG_From_int(static_cast< int >(AssignRuleParameterMismatch)));
  SWIG_Python_SetConstant(d, "AssignRuleStoichiometryMismatch",SWIG_From_int(static_cast< int >(AssignRuleStoichiometryMismatch)));
  SWIG_Python_SetConstant(d, "InitAssignCompartmenMismatch",SWIG_From_int(static_cast< int >(InitAssignCompartmenMismatch)));
  SWIG_Python_SetConstant(d, "InitAssignSpeciesMismatch",SWIG_From_int(static_cast< int >(InitAssignSpeciesMismatch)));
  SWIG_Python_SetConstant(d, "InitAssignParameterMismatch",SWIG_From_int(static_cast< int >(InitAssignParameterMismatch)));
  SWIG_Python_SetConstant(d, "InitAssignStoichiometryMismatch",SWIG_From_int(static_cast< int >(InitAssignStoichiometryMismatch)));
  SWIG_Python_SetConstant(d, "RateRuleCompartmentMismatch",SWIG_From_int(static_cast< int >(RateRuleCompartmentMismatch)));
  SWIG_Python_SetConstant(d, "RateRuleSpeciesMismatch",SWIG_From_int(static_cast< int >(RateRuleSpeciesMismatch)));
  SWIG_Python_SetConstant(d, "RateRuleParameterMismatch",SWIG_From_int(static_cast< int >(RateRuleParameterMismatch)));
  SWIG_Python_SetConstant(d, "RateRuleStoichiometryMismatch",SWIG_From_int(static_cast< int >(RateRuleStoichiometryMismatch)));
  SWIG_Python_SetConstant(d, "KineticLawNotSubstancePerTime",SWIG_From_int(static_cast< int >(KineticLawNotSubstancePerTime)));
  SWIG_Python_SetConstant(d, "SpeciesInvalidExtentUnits",SWIG_From_int(static_cast< int >(SpeciesInvalidExtentUnits)));
  SWIG_Python_SetConstant(d, "DelayUnitsNotTime",SWIG_From_int(static_cast< int >(DelayUnitsNotTime)));
  SWIG_Python_SetConstant(d, "EventAssignCompartmentMismatch",SWIG_From_int(static_cast< int >(EventAssignCompartmentMismatch)));
  SWIG_Python_SetConstant(d, "EventAssignSpeciesMismatch",SWIG_From_int(static_cast< int >(EventAssignSpeciesMismatch)));
  SWIG_Python_SetConstant(d, "EventAssignParameterMismatch",SWIG_From_int(static_cast< int >(EventAssignParameterMismatch)));
  SWIG_Python_SetConstant(d, "EventAssignStoichiometryMismatch",SWIG_From_int(static_cast< int >(EventAssignStoichiometryMismatch)));
  SWIG_Python_SetConstant(d, "PriorityUnitsNotDimensionless",SWIG_From_int(static_cast< int >(PriorityUnitsNotDimensionless)));
  SWIG_Python_SetConstant(d, "UpperUnitBound",SWIG_From_int(static_cast< int >(UpperUnitBound)));
  SWIG_Python_SetConstant(d, "OverdeterminedSystem",SWIG_From_int(static_cast< int >(OverdeterminedSystem)));
  SWIG_Python_SetConstant(d, "InvalidModelSBOTerm",SWIG_From_int(static_cast< int >(InvalidModelSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidFunctionDefSBOTerm",SWIG_From_int(static_cast< int >(InvalidFunctionDefSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidParameterSBOTerm",SWIG_From_int(static_cast< int >(InvalidParameterSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidInitAssignSBOTerm",SWIG_From_int(static_cast< int >(InvalidInitAssignSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidRuleSBOTerm",SWIG_From_int(static_cast< int >(InvalidRuleSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidConstraintSBOTerm",SWIG_From_int(static_cast< int >(InvalidConstraintSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidReactionSBOTerm",SWIG_From_int(static_cast< int >(InvalidReactionSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidSpeciesReferenceSBOTerm",SWIG_From_int(static_cast< int >(InvalidSpeciesReferenceSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidKineticLawSBOTerm",SWIG_From_int(static_cast< int >(InvalidKineticLawSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidEventSBOTerm",SWIG_From_int(static_cast< int >(InvalidEventSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidEventAssignmentSBOTerm",SWIG_From_int(static_cast< int >(InvalidEventAssignmentSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidCompartmentSBOTerm",SWIG_From_int(static_cast< int >(InvalidCompartmentSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidSpeciesSBOTerm",SWIG_From_int(static_cast< int >(InvalidSpeciesSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidCompartmentTypeSBOTerm",SWIG_From_int(static_cast< int >(InvalidCompartmentTypeSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidSpeciesTypeSBOTerm",SWIG_From_int(static_cast< int >(InvalidSpeciesTypeSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidTriggerSBOTerm",SWIG_From_int(static_cast< int >(InvalidTriggerSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidDelaySBOTerm",SWIG_From_int(static_cast< int >(InvalidDelaySBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidLocalParameterSBOTerm",SWIG_From_int(static_cast< int >(InvalidLocalParameterSBOTerm)));
  SWIG_Python_SetConstant(d, "InvalidSBMLElementSBOTerm",SWIG_From_int(static_cast< int >(InvalidSBMLElementSBOTerm)));
  SWIG_Python_SetConstant(d, "NotesNotInXHTMLNamespace",SWIG_From_int(static_cast< int >(NotesNotInXHTMLNamespace)));
  SWIG_Python_SetConstant(d, "NotesContainsXMLDecl",SWIG_From_int(static_cast< int >(NotesContainsXMLDecl)));
  SWIG_Python_SetConstant(d, "NotesContainsDOCTYPE",SWIG_From_int(static_cast< int >(NotesContainsDOCTYPE)));
  SWIG_Python_SetConstant(d, "InvalidNotesContent",SWIG_From_int(static_cast< int >(InvalidNotesContent)));
  SWIG_Python_SetConstant(d, "OnlyOneNotesElementAllowed",SWIG_From_int(static_cast< int >(OnlyOneNotesElementAllowed)));
  SWIG_Python_SetConstant(d, "InvalidNamespaceOnSBML",SWIG_From_int(static_cast< int >(InvalidNamespaceOnSBML)));
  SWIG_Python_SetConstant(d, "MissingOrInconsistentLevel",SWIG_From_int(static_cast< int >(MissingOrInconsistentLevel)));
  SWIG_Python_SetConstant(d, "MissingOrInconsistentVersion",SWIG_From_int(static_cast< int >(MissingOrInconsistentVersion)));
  SWIG_Python_SetConstant(d, "PackageNSMustMatch",SWIG_From_int(static_cast< int >(PackageNSMustMatch)));
  SWIG_Python_SetConstant(d, "LevelPositiveInteger",SWIG_From_int(static_cast< int >(LevelPositiveInteger)));
  SWIG_Python_SetConstant(d, "VersionPositiveInteger",SWIG_From_int(static_cast< int >(VersionPositiveInteger)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnSBML",SWIG_From_int(static_cast< int >(AllowedAttributesOnSBML)));
  SWIG_Python_SetConstant(d, "L3PackageOnLowerSBML",SWIG_From_int(static_cast< int >(L3PackageOnLowerSBML)));
  SWIG_Python_SetConstant(d, "MissingModel",SWIG_From_int(static_cast< int >(MissingModel)));
  SWIG_Python_SetConstant(d, "IncorrectOrderInModel",SWIG_From_int(static_cast< int >(IncorrectOrderInModel)));
  SWIG_Python_SetConstant(d, "EmptyListElement",SWIG_From_int(static_cast< int >(EmptyListElement)));
  SWIG_Python_SetConstant(d, "NeedCompartmentIfHaveSpecies",SWIG_From_int(static_cast< int >(NeedCompartmentIfHaveSpecies)));
  SWIG_Python_SetConstant(d, "OneOfEachListOf",SWIG_From_int(static_cast< int >(OneOfEachListOf)));
  SWIG_Python_SetConstant(d, "OnlyFuncDefsInListOfFuncDefs",SWIG_From_int(static_cast< int >(OnlyFuncDefsInListOfFuncDefs)));
  SWIG_Python_SetConstant(d, "OnlyUnitDefsInListOfUnitDefs",SWIG_From_int(static_cast< int >(OnlyUnitDefsInListOfUnitDefs)));
  SWIG_Python_SetConstant(d, "OnlyCompartmentsInListOfCompartments",SWIG_From_int(static_cast< int >(OnlyCompartmentsInListOfCompartments)));
  SWIG_Python_SetConstant(d, "OnlySpeciesInListOfSpecies",SWIG_From_int(static_cast< int >(OnlySpeciesInListOfSpecies)));
  SWIG_Python_SetConstant(d, "OnlyParametersInListOfParameters",SWIG_From_int(static_cast< int >(OnlyParametersInListOfParameters)));
  SWIG_Python_SetConstant(d, "OnlyInitAssignsInListOfInitAssigns",SWIG_From_int(static_cast< int >(OnlyInitAssignsInListOfInitAssigns)));
  SWIG_Python_SetConstant(d, "OnlyRulesInListOfRules",SWIG_From_int(static_cast< int >(OnlyRulesInListOfRules)));
  SWIG_Python_SetConstant(d, "OnlyConstraintsInListOfConstraints",SWIG_From_int(static_cast< int >(OnlyConstraintsInListOfConstraints)));
  SWIG_Python_SetConstant(d, "OnlyReactionsInListOfReactions",SWIG_From_int(static_cast< int >(OnlyReactionsInListOfReactions)));
  SWIG_Python_SetConstant(d, "OnlyEventsInListOfEvents",SWIG_From_int(static_cast< int >(OnlyEventsInListOfEvents)));
  SWIG_Python_SetConstant(d, "L3ConversionFactorOnModel",SWIG_From_int(static_cast< int >(L3ConversionFactorOnModel)));
  SWIG_Python_SetConstant(d, "L3TimeUnitsOnModel",SWIG_From_int(static_cast< int >(L3TimeUnitsOnModel)));
  SWIG_Python_SetConstant(d, "L3VolumeUnitsOnModel",SWIG_From_int(static_cast< int >(L3VolumeUnitsOnModel)));
  SWIG_Python_SetConstant(d, "L3AreaUnitsOnModel",SWIG_From_int(static_cast< int >(L3AreaUnitsOnModel)));
  SWIG_Python_SetConstant(d, "L3LengthUnitsOnModel",SWIG_From_int(static_cast< int >(L3LengthUnitsOnModel)));
  SWIG_Python_SetConstant(d, "L3ExtentUnitsOnModel",SWIG_From_int(static_cast< int >(L3ExtentUnitsOnModel)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnModel",SWIG_From_int(static_cast< int >(AllowedAttributesOnModel)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfFuncs",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfFuncs)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfUnitDefs",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfUnitDefs)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfComps",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfComps)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfSpecies",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfSpecies)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfParams",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfParams)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfInitAssign",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfInitAssign)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfRules",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfRules)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfConstraints",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfConstraints)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfReactions",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfReactions)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfEvents",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfEvents)));
  SWIG_Python_SetConstant(d, "L3V2SubstanceUnitsOnModel",SWIG_From_int(static_cast< int >(L3V2SubstanceUnitsOnModel)));
  SWIG_Python_SetConstant(d, "FunctionDefMathNotLambda",SWIG_From_int(static_cast< int >(FunctionDefMathNotLambda)));
  SWIG_Python_SetConstant(d, "InvalidApplyCiInLambda",SWIG_From_int(static_cast< int >(InvalidApplyCiInLambda)));
  SWIG_Python_SetConstant(d, "RecursiveFunctionDefinition",SWIG_From_int(static_cast< int >(RecursiveFunctionDefinition)));
  SWIG_Python_SetConstant(d, "InvalidCiInLambda",SWIG_From_int(static_cast< int >(InvalidCiInLambda)));
  SWIG_Python_SetConstant(d, "InvalidFunctionDefReturnType",SWIG_From_int(static_cast< int >(InvalidFunctionDefReturnType)));
  SWIG_Python_SetConstant(d, "OneMathElementPerFunc",SWIG_From_int(static_cast< int >(OneMathElementPerFunc)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnFunc",SWIG_From_int(static_cast< int >(AllowedAttributesOnFunc)));
  SWIG_Python_SetConstant(d, "OnlyCiInsideBVar",SWIG_From_int(static_cast< int >(OnlyCiInsideBVar)));
  SWIG_Python_SetConstant(d, "InvalidUnitDefId",SWIG_From_int(static_cast< int >(InvalidUnitDefId)));
  SWIG_Python_SetConstant(d, "InvalidSubstanceRedefinition",SWIG_From_int(static_cast< int >(InvalidSubstanceRedefinition)));
  SWIG_Python_SetConstant(d, "InvalidLengthRedefinition",SWIG_From_int(static_cast< int >(InvalidLengthRedefinition)));
  SWIG_Python_SetConstant(d, "InvalidAreaRedefinition",SWIG_From_int(static_cast< int >(InvalidAreaRedefinition)));
  SWIG_Python_SetConstant(d, "InvalidTimeRedefinition",SWIG_From_int(static_cast< int >(InvalidTimeRedefinition)));
  SWIG_Python_SetConstant(d, "InvalidVolumeRedefinition",SWIG_From_int(static_cast< int >(InvalidVolumeRedefinition)));
  SWIG_Python_SetConstant(d, "VolumeLitreDefExponentNotOne",SWIG_From_int(static_cast< int >(VolumeLitreDefExponentNotOne)));
  SWIG_Python_SetConstant(d, "VolumeMetreDefExponentNot3",SWIG_From_int(static_cast< int >(VolumeMetreDefExponentNot3)));
  SWIG_Python_SetConstant(d, "EmptyListOfUnits",SWIG_From_int(static_cast< int >(EmptyListOfUnits)));
  SWIG_Python_SetConstant(d, "InvalidUnitKind",SWIG_From_int(static_cast< int >(InvalidUnitKind)));
  SWIG_Python_SetConstant(d, "OffsetNoLongerValid",SWIG_From_int(static_cast< int >(OffsetNoLongerValid)));
  SWIG_Python_SetConstant(d, "CelsiusNoLongerValid",SWIG_From_int(static_cast< int >(CelsiusNoLongerValid)));
  SWIG_Python_SetConstant(d, "EmptyUnitListElement",SWIG_From_int(static_cast< int >(EmptyUnitListElement)));
  SWIG_Python_SetConstant(d, "OneListOfUnitsPerUnitDef",SWIG_From_int(static_cast< int >(OneListOfUnitsPerUnitDef)));
  SWIG_Python_SetConstant(d, "OnlyUnitsInListOfUnits",SWIG_From_int(static_cast< int >(OnlyUnitsInListOfUnits)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnUnitDefinition",SWIG_From_int(static_cast< int >(AllowedAttributesOnUnitDefinition)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfUnits",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfUnits)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnUnit",SWIG_From_int(static_cast< int >(AllowedAttributesOnUnit)));
  SWIG_Python_SetConstant(d, "ZeroDimensionalCompartmentSize",SWIG_From_int(static_cast< int >(ZeroDimensionalCompartmentSize)));
  SWIG_Python_SetConstant(d, "ZeroDimensionalCompartmentUnits",SWIG_From_int(static_cast< int >(ZeroDimensionalCompartmentUnits)));
  SWIG_Python_SetConstant(d, "ZeroDimensionalCompartmentConst",SWIG_From_int(static_cast< int >(ZeroDimensionalCompartmentConst)));
  SWIG_Python_SetConstant(d, "UndefinedOutsideCompartment",SWIG_From_int(static_cast< int >(UndefinedOutsideCompartment)));
  SWIG_Python_SetConstant(d, "RecursiveCompartmentContainment",SWIG_From_int(static_cast< int >(RecursiveCompartmentContainment)));
  SWIG_Python_SetConstant(d, "ZeroDCompartmentContainment",SWIG_From_int(static_cast< int >(ZeroDCompartmentContainment)));
  SWIG_Python_SetConstant(d, "Invalid1DCompartmentUnits",SWIG_From_int(static_cast< int >(Invalid1DCompartmentUnits)));
  SWIG_Python_SetConstant(d, "Invalid2DCompartmentUnits",SWIG_From_int(static_cast< int >(Invalid2DCompartmentUnits)));
  SWIG_Python_SetConstant(d, "Invalid3DCompartmentUnits",SWIG_From_int(static_cast< int >(Invalid3DCompartmentUnits)));
  SWIG_Python_SetConstant(d, "InvalidCompartmentTypeRef",SWIG_From_int(static_cast< int >(InvalidCompartmentTypeRef)));
  SWIG_Python_SetConstant(d, "OneDimensionalCompartmentUnits",SWIG_From_int(static_cast< int >(OneDimensionalCompartmentUnits)));
  SWIG_Python_SetConstant(d, "TwoDimensionalCompartmentUnits",SWIG_From_int(static_cast< int >(TwoDimensionalCompartmentUnits)));
  SWIG_Python_SetConstant(d, "ThreeDimensionalCompartmentUnits",SWIG_From_int(static_cast< int >(ThreeDimensionalCompartmentUnits)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnCompartment",SWIG_From_int(static_cast< int >(AllowedAttributesOnCompartment)));
  SWIG_Python_SetConstant(d, "NoUnitsOnCompartment",SWIG_From_int(static_cast< int >(NoUnitsOnCompartment)));
  SWIG_Python_SetConstant(d, "InvalidSpeciesCompartmentRef",SWIG_From_int(static_cast< int >(InvalidSpeciesCompartmentRef)));
  SWIG_Python_SetConstant(d, "HasOnlySubsNoSpatialUnits",SWIG_From_int(static_cast< int >(HasOnlySubsNoSpatialUnits)));
  SWIG_Python_SetConstant(d, "NoSpatialUnitsInZeroD",SWIG_From_int(static_cast< int >(NoSpatialUnitsInZeroD)));
  SWIG_Python_SetConstant(d, "NoConcentrationInZeroD",SWIG_From_int(static_cast< int >(NoConcentrationInZeroD)));
  SWIG_Python_SetConstant(d, "SpatialUnitsInOneD",SWIG_From_int(static_cast< int >(SpatialUnitsInOneD)));
  SWIG_Python_SetConstant(d, "SpatialUnitsInTwoD",SWIG_From_int(static_cast< int >(SpatialUnitsInTwoD)));
  SWIG_Python_SetConstant(d, "SpatialUnitsInThreeD",SWIG_From_int(static_cast< int >(SpatialUnitsInThreeD)));
  SWIG_Python_SetConstant(d, "InvalidSpeciesSusbstanceUnits",SWIG_From_int(static_cast< int >(InvalidSpeciesSusbstanceUnits)));
  SWIG_Python_SetConstant(d, "BothAmountAndConcentrationSet",SWIG_From_int(static_cast< int >(BothAmountAndConcentrationSet)));
  SWIG_Python_SetConstant(d, "NonBoundarySpeciesAssignedAndUsed",SWIG_From_int(static_cast< int >(NonBoundarySpeciesAssignedAndUsed)));
  SWIG_Python_SetConstant(d, "NonConstantSpeciesUsed",SWIG_From_int(static_cast< int >(NonConstantSpeciesUsed)));
  SWIG_Python_SetConstant(d, "InvalidSpeciesTypeRef",SWIG_From_int(static_cast< int >(InvalidSpeciesTypeRef)));
  SWIG_Python_SetConstant(d, "MultSpeciesSameTypeInCompartment",SWIG_From_int(static_cast< int >(MultSpeciesSameTypeInCompartment)));
  SWIG_Python_SetConstant(d, "MissingSpeciesCompartment",SWIG_From_int(static_cast< int >(MissingSpeciesCompartment)));
  SWIG_Python_SetConstant(d, "SpatialSizeUnitsRemoved",SWIG_From_int(static_cast< int >(SpatialSizeUnitsRemoved)));
  SWIG_Python_SetConstant(d, "SubstanceUnitsOnSpecies",SWIG_From_int(static_cast< int >(SubstanceUnitsOnSpecies)));
  SWIG_Python_SetConstant(d, "ConversionFactorOnSpecies",SWIG_From_int(static_cast< int >(ConversionFactorOnSpecies)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnSpecies",SWIG_From_int(static_cast< int >(AllowedAttributesOnSpecies)));
  SWIG_Python_SetConstant(d, "InvalidParameterUnits",SWIG_From_int(static_cast< int >(InvalidParameterUnits)));
  SWIG_Python_SetConstant(d, "ParameterUnits",SWIG_From_int(static_cast< int >(ParameterUnits)));
  SWIG_Python_SetConstant(d, "ConversionFactorMustConstant",SWIG_From_int(static_cast< int >(ConversionFactorMustConstant)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnParameter",SWIG_From_int(static_cast< int >(AllowedAttributesOnParameter)));
  SWIG_Python_SetConstant(d, "InvalidInitAssignSymbol",SWIG_From_int(static_cast< int >(InvalidInitAssignSymbol)));
  SWIG_Python_SetConstant(d, "MultipleInitAssignments",SWIG_From_int(static_cast< int >(MultipleInitAssignments)));
  SWIG_Python_SetConstant(d, "InitAssignmentAndRuleForSameId",SWIG_From_int(static_cast< int >(InitAssignmentAndRuleForSameId)));
  SWIG_Python_SetConstant(d, "OneMathElementPerInitialAssign",SWIG_From_int(static_cast< int >(OneMathElementPerInitialAssign)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnInitialAssign",SWIG_From_int(static_cast< int >(AllowedAttributesOnInitialAssign)));
  SWIG_Python_SetConstant(d, "InitAssignmentCannotRef0DComp",SWIG_From_int(static_cast< int >(InitAssignmentCannotRef0DComp)));
  SWIG_Python_SetConstant(d, "InvalidAssignRuleVariable",SWIG_From_int(static_cast< int >(InvalidAssignRuleVariable)));
  SWIG_Python_SetConstant(d, "InvalidRateRuleVariable",SWIG_From_int(static_cast< int >(InvalidRateRuleVariable)));
  SWIG_Python_SetConstant(d, "AssignmentToConstantEntity",SWIG_From_int(static_cast< int >(AssignmentToConstantEntity)));
  SWIG_Python_SetConstant(d, "RateRuleForConstantEntity",SWIG_From_int(static_cast< int >(RateRuleForConstantEntity)));
  SWIG_Python_SetConstant(d, "RepeatedRule10304",SWIG_From_int(static_cast< int >(RepeatedRule10304)));
  SWIG_Python_SetConstant(d, "CircularRuleDependency",SWIG_From_int(static_cast< int >(CircularRuleDependency)));
  SWIG_Python_SetConstant(d, "OneMathElementPerRule",SWIG_From_int(static_cast< int >(OneMathElementPerRule)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnAssignRule",SWIG_From_int(static_cast< int >(AllowedAttributesOnAssignRule)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnRateRule",SWIG_From_int(static_cast< int >(AllowedAttributesOnRateRule)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnAlgRule",SWIG_From_int(static_cast< int >(AllowedAttributesOnAlgRule)));
  SWIG_Python_SetConstant(d, "RuleCannotRef0DComp",SWIG_From_int(static_cast< int >(RuleCannotRef0DComp)));
  SWIG_Python_SetConstant(d, "CircularDependencyRateOf",SWIG_From_int(static_cast< int >(CircularDependencyRateOf)));
  SWIG_Python_SetConstant(d, "ConstraintMathNotBoolean",SWIG_From_int(static_cast< int >(ConstraintMathNotBoolean)));
  SWIG_Python_SetConstant(d, "IncorrectOrderInConstraint",SWIG_From_int(static_cast< int >(IncorrectOrderInConstraint)));
  SWIG_Python_SetConstant(d, "ConstraintNotInXHTMLNamespace",SWIG_From_int(static_cast< int >(ConstraintNotInXHTMLNamespace)));
  SWIG_Python_SetConstant(d, "ConstraintContainsXMLDecl",SWIG_From_int(static_cast< int >(ConstraintContainsXMLDecl)));
  SWIG_Python_SetConstant(d, "ConstraintContainsDOCTYPE",SWIG_From_int(static_cast< int >(ConstraintContainsDOCTYPE)));
  SWIG_Python_SetConstant(d, "InvalidConstraintContent",SWIG_From_int(static_cast< int >(InvalidConstraintContent)));
  SWIG_Python_SetConstant(d, "OneMathElementPerConstraint",SWIG_From_int(static_cast< int >(OneMathElementPerConstraint)));
  SWIG_Python_SetConstant(d, "OneMessageElementPerConstraint",SWIG_From_int(static_cast< int >(OneMessageElementPerConstraint)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnConstraint",SWIG_From_int(static_cast< int >(AllowedAttributesOnConstraint)));
  SWIG_Python_SetConstant(d, "NoReactantsOrProducts",SWIG_From_int(static_cast< int >(NoReactantsOrProducts)));
  SWIG_Python_SetConstant(d, "IncorrectOrderInReaction",SWIG_From_int(static_cast< int >(IncorrectOrderInReaction)));
  SWIG_Python_SetConstant(d, "EmptyListInReaction",SWIG_From_int(static_cast< int >(EmptyListInReaction)));
  SWIG_Python_SetConstant(d, "InvalidReactantsProductsList",SWIG_From_int(static_cast< int >(InvalidReactantsProductsList)));
  SWIG_Python_SetConstant(d, "InvalidModifiersList",SWIG_From_int(static_cast< int >(InvalidModifiersList)));
  SWIG_Python_SetConstant(d, "OneSubElementPerReaction",SWIG_From_int(static_cast< int >(OneSubElementPerReaction)));
  SWIG_Python_SetConstant(d, "CompartmentOnReaction",SWIG_From_int(static_cast< int >(CompartmentOnReaction)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnReaction",SWIG_From_int(static_cast< int >(AllowedAttributesOnReaction)));
  SWIG_Python_SetConstant(d, "InvalidSpeciesReference",SWIG_From_int(static_cast< int >(InvalidSpeciesReference)));
  SWIG_Python_SetConstant(d, "RepeatedRule20611",SWIG_From_int(static_cast< int >(RepeatedRule20611)));
  SWIG_Python_SetConstant(d, "BothStoichiometryAndMath",SWIG_From_int(static_cast< int >(BothStoichiometryAndMath)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnSpeciesReference",SWIG_From_int(static_cast< int >(AllowedAttributesOnSpeciesReference)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnModifier",SWIG_From_int(static_cast< int >(AllowedAttributesOnModifier)));
  SWIG_Python_SetConstant(d, "UndeclaredSpeciesRef",SWIG_From_int(static_cast< int >(UndeclaredSpeciesRef)));
  SWIG_Python_SetConstant(d, "IncorrectOrderInKineticLaw",SWIG_From_int(static_cast< int >(IncorrectOrderInKineticLaw)));
  SWIG_Python_SetConstant(d, "EmptyListInKineticLaw",SWIG_From_int(static_cast< int >(EmptyListInKineticLaw)));
  SWIG_Python_SetConstant(d, "NonConstantLocalParameter",SWIG_From_int(static_cast< int >(NonConstantLocalParameter)));
  SWIG_Python_SetConstant(d, "SubsUnitsNoLongerValid",SWIG_From_int(static_cast< int >(SubsUnitsNoLongerValid)));
  SWIG_Python_SetConstant(d, "TimeUnitsNoLongerValid",SWIG_From_int(static_cast< int >(TimeUnitsNoLongerValid)));
  SWIG_Python_SetConstant(d, "OneListOfPerKineticLaw",SWIG_From_int(static_cast< int >(OneListOfPerKineticLaw)));
  SWIG_Python_SetConstant(d, "OnlyLocalParamsInListOfLocalParams",SWIG_From_int(static_cast< int >(OnlyLocalParamsInListOfLocalParams)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfLocalParam",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfLocalParam)));
  SWIG_Python_SetConstant(d, "OneMathPerKineticLaw",SWIG_From_int(static_cast< int >(OneMathPerKineticLaw)));
  SWIG_Python_SetConstant(d, "UndeclaredSpeciesInStoichMath",SWIG_From_int(static_cast< int >(UndeclaredSpeciesInStoichMath)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnKineticLaw",SWIG_From_int(static_cast< int >(AllowedAttributesOnKineticLaw)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfSpeciesRef",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfSpeciesRef)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfMods",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfMods)));
  SWIG_Python_SetConstant(d, "L3V2FastDeprecated",SWIG_From_int(static_cast< int >(L3V2FastDeprecated)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnLocalParameter",SWIG_From_int(static_cast< int >(AllowedAttributesOnLocalParameter)));
  SWIG_Python_SetConstant(d, "LocalParameterShadowsSpecies",SWIG_From_int(static_cast< int >(LocalParameterShadowsSpecies)));
  SWIG_Python_SetConstant(d, "MissingTriggerInEvent",SWIG_From_int(static_cast< int >(MissingTriggerInEvent)));
  SWIG_Python_SetConstant(d, "TriggerMathNotBoolean",SWIG_From_int(static_cast< int >(TriggerMathNotBoolean)));
  SWIG_Python_SetConstant(d, "MissingEventAssignment",SWIG_From_int(static_cast< int >(MissingEventAssignment)));
  SWIG_Python_SetConstant(d, "TimeUnitsEvent",SWIG_From_int(static_cast< int >(TimeUnitsEvent)));
  SWIG_Python_SetConstant(d, "IncorrectOrderInEvent",SWIG_From_int(static_cast< int >(IncorrectOrderInEvent)));
  SWIG_Python_SetConstant(d, "ValuesFromTriggerTimeNeedDelay",SWIG_From_int(static_cast< int >(ValuesFromTriggerTimeNeedDelay)));
  SWIG_Python_SetConstant(d, "DelayNeedsValuesFromTriggerTime",SWIG_From_int(static_cast< int >(DelayNeedsValuesFromTriggerTime)));
  SWIG_Python_SetConstant(d, "OneMathPerTrigger",SWIG_From_int(static_cast< int >(OneMathPerTrigger)));
  SWIG_Python_SetConstant(d, "OneMathPerDelay",SWIG_From_int(static_cast< int >(OneMathPerDelay)));
  SWIG_Python_SetConstant(d, "InvalidEventAssignmentVariable",SWIG_From_int(static_cast< int >(InvalidEventAssignmentVariable)));
  SWIG_Python_SetConstant(d, "EventAssignmentForConstantEntity",SWIG_From_int(static_cast< int >(EventAssignmentForConstantEntity)));
  SWIG_Python_SetConstant(d, "OneMathPerEventAssignment",SWIG_From_int(static_cast< int >(OneMathPerEventAssignment)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnEventAssignment",SWIG_From_int(static_cast< int >(AllowedAttributesOnEventAssignment)));
  SWIG_Python_SetConstant(d, "OnlyOneDelayPerEvent",SWIG_From_int(static_cast< int >(OnlyOneDelayPerEvent)));
  SWIG_Python_SetConstant(d, "OneListOfEventAssignmentsPerEvent",SWIG_From_int(static_cast< int >(OneListOfEventAssignmentsPerEvent)));
  SWIG_Python_SetConstant(d, "OnlyEventAssignInListOfEventAssign",SWIG_From_int(static_cast< int >(OnlyEventAssignInListOfEventAssign)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnListOfEventAssign",SWIG_From_int(static_cast< int >(AllowedAttributesOnListOfEventAssign)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnEvent",SWIG_From_int(static_cast< int >(AllowedAttributesOnEvent)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnTrigger",SWIG_From_int(static_cast< int >(AllowedAttributesOnTrigger)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnDelay",SWIG_From_int(static_cast< int >(AllowedAttributesOnDelay)));
  SWIG_Python_SetConstant(d, "PersistentNotBoolean",SWIG_From_int(static_cast< int >(PersistentNotBoolean)));
  SWIG_Python_SetConstant(d, "InitialValueNotBoolean",SWIG_From_int(static_cast< int >(InitialValueNotBoolean)));
  SWIG_Python_SetConstant(d, "OnlyOnePriorityPerEvent",SWIG_From_int(static_cast< int >(OnlyOnePriorityPerEvent)));
  SWIG_Python_SetConstant(d, "OneMathPerPriority",SWIG_From_int(static_cast< int >(OneMathPerPriority)));
  SWIG_Python_SetConstant(d, "AllowedAttributesOnPriority",SWIG_From_int(static_cast< int >(AllowedAttributesOnPriority)));
  SWIG_Python_SetConstant(d, "GeneralWarningNotSpecified",SWIG_From_int(static_cast< int >(GeneralWarningNotSpecified)));
  SWIG_Python_SetConstant(d, "CompartmentShouldHaveSize",SWIG_From_int(static_cast< int >(CompartmentShouldHaveSize)));
  SWIG_Python_SetConstant(d, "SpeciesShouldHaveValue",SWIG_From_int(static_cast< int >(SpeciesShouldHaveValue)));
  SWIG_Python_SetConstant(d, "ParameterShouldHaveUnits",SWIG_From_int(static_cast< int >(ParameterShouldHaveUnits)));
  SWIG_Python_SetConstant(d, "ParameterShouldHaveValue",SWIG_From_int(static_cast< int >(ParameterShouldHaveValue)));
  SWIG_Python_SetConstant(d, "LocalParameterShadowsId",SWIG_From_int(static_cast< int >(LocalParameterShadowsId)));
  SWIG_Python_SetConstant(d, "LibSBMLAdditionalCodesLowerBound",SWIG_From_int(static_cast< int >(LibSBMLAdditionalCodesLowerBound)));
  SWIG_Python_SetConstant(d, "CannotConvertToL1V1",SWIG_From_int(static_cast< int >(CannotConvertToL1V1)));
  SWIG_Python_SetConstant(d, "NoEventsInL1",SWIG_From_int(static_cast< int >(NoEventsInL1)));
  SWIG_Python_SetConstant(d, "NoFunctionDefinitionsInL1",SWIG_From_int(static_cast< int >(NoFunctionDefinitionsInL1)));
  SWIG_Python_SetConstant(d, "NoConstraintsInL1",SWIG_From_int(static_cast< int >(NoConstraintsInL1)));
  SWIG_Python_SetConstant(d, "NoInitialAssignmentsInL1",SWIG_From_int(static_cast< int >(NoInitialAssignmentsInL1)));
  SWIG_Python_SetConstant(d, "NoSpeciesTypesInL1",SWIG_From_int(static_cast< int >(NoSpeciesTypesInL1)));
  SWIG_Python_SetConstant(d, "NoCompartmentTypeInL1",SWIG_From_int(static_cast< int >(NoCompartmentTypeInL1)));
  SWIG_Python_SetConstant(d, "NoNon3DCompartmentsInL1",SWIG_From_int(static_cast< int >(NoNon3DCompartmentsInL1)));
  SWIG_Python_SetConstant(d, "NoFancyStoichiometryMathInL1",SWIG_From_int(static_cast< int >(NoFancyStoichiometryMathInL1)));
  SWIG_Python_SetConstant(d, "NoNonIntegerStoichiometryInL1",SWIG_From_int(static_cast< int >(NoNonIntegerStoichiometryInL1)));
  SWIG_Python_SetConstant(d, "NoUnitMultipliersOrOffsetsInL1",SWIG_From_int(static_cast< int >(NoUnitMultipliersOrOffsetsInL1)));
  SWIG_Python_SetConstant(d, "SpeciesCompartmentRequiredInL1",SWIG_From_int(static_cast< int >(SpeciesCompartmentRequiredInL1)));
  SWIG_Python_SetConstant(d, "NoSpeciesSpatialSizeUnitsInL1",SWIG_From_int(static_cast< int >(NoSpeciesSpatialSizeUnitsInL1)));
  SWIG_Python_SetConstant(d, "NoSBOTermsInL1",SWIG_From_int(static_cast< int >(NoSBOTermsInL1)));
  SWIG_Python_SetConstant(d, "StrictUnitsRequiredInL1",SWIG_From_int(static_cast< int >(StrictUnitsRequiredInL1)));
  SWIG_Python_SetConstant(d, "ConversionFactorNotInL1",SWIG_From_int(static_cast< int >(ConversionFactorNotInL1)));
  SWIG_Python_SetConstant(d, "CompartmentNotOnL1Reaction",SWIG_From_int(static_cast< int >(CompartmentNotOnL1Reaction)));
  SWIG_Python_SetConstant(d, "ExtentUnitsNotSubstance",SWIG_From_int(static_cast< int >(ExtentUnitsNotSubstance)));
  SWIG_Python_SetConstant(d, "GlobalUnitsNotDeclared",SWIG_From_int(static_cast< int >(GlobalUnitsNotDeclared)));
  SWIG_Python_SetConstant(d, "HasOnlySubstanceUnitsNotinL1",SWIG_From_int(static_cast< int >(HasOnlySubstanceUnitsNotinL1)));
  SWIG_Python_SetConstant(d, "AvogadroNotSupported",SWIG_From_int(static_cast< int >(AvogadroNotSupported)));
  SWIG_Python_SetConstant(d, "NoConstraintsInL2v1",SWIG_From_int(static_cast< int >(NoConstraintsInL2v1)));
  SWIG_Python_SetConstant(d, "NoInitialAssignmentsInL2v1",SWIG_From_int(static_cast< int >(NoInitialAssignmentsInL2v1)));
  SWIG_Python_SetConstant(d, "NoSpeciesTypeInL2v1",SWIG_From_int(static_cast< int >(NoSpeciesTypeInL2v1)));
  SWIG_Python_SetConstant(d, "NoCompartmentTypeInL2v1",SWIG_From_int(static_cast< int >(NoCompartmentTypeInL2v1)));
  SWIG_Python_SetConstant(d, "NoSBOTermsInL2v1",SWIG_From_int(static_cast< int >(NoSBOTermsInL2v1)));
  SWIG_Python_SetConstant(d, "NoIdOnSpeciesReferenceInL2v1",SWIG_From_int(static_cast< int >(NoIdOnSpeciesReferenceInL2v1)));
  SWIG_Python_SetConstant(d, "NoDelayedEventAssignmentInL2v1",SWIG_From_int(static_cast< int >(NoDelayedEventAssignmentInL2v1)));
  SWIG_Python_SetConstant(d, "StrictUnitsRequiredInL2v1",SWIG_From_int(static_cast< int >(StrictUnitsRequiredInL2v1)));
  SWIG_Python_SetConstant(d, "IntegerSpatialDimensions",SWIG_From_int(static_cast< int >(IntegerSpatialDimensions)));
  SWIG_Python_SetConstant(d, "StoichiometryMathNotYetSupported",SWIG_From_int(static_cast< int >(StoichiometryMathNotYetSupported)));
  SWIG_Python_SetConstant(d, "PriorityLostFromL3",SWIG_From_int(static_cast< int >(PriorityLostFromL3)));
  SWIG_Python_SetConstant(d, "NonPersistentNotSupported",SWIG_From_int(static_cast< int >(NonPersistentNotSupported)));
  SWIG_Python_SetConstant(d, "InitialValueFalseEventNotSupported",SWIG_From_int(static_cast< int >(InitialValueFalseEventNotSupported)));
  SWIG_Python_SetConstant(d, "SBOTermNotUniversalInL2v2",SWIG_From_int(static_cast< int >(SBOTermNotUniversalInL2v2)));
  SWIG_Python_SetConstant(d, "NoUnitOffsetInL2v2",SWIG_From_int(static_cast< int >(NoUnitOffsetInL2v2)));
  SWIG_Python_SetConstant(d, "NoKineticLawTimeUnitsInL2v2",SWIG_From_int(static_cast< int >(NoKineticLawTimeUnitsInL2v2)));
  SWIG_Python_SetConstant(d, "NoKineticLawSubstanceUnitsInL2v2",SWIG_From_int(static_cast< int >(NoKineticLawSubstanceUnitsInL2v2)));
  SWIG_Python_SetConstant(d, "NoDelayedEventAssignmentInL2v2",SWIG_From_int(static_cast< int >(NoDelayedEventAssignmentInL2v2)));
  SWIG_Python_SetConstant(d, "ModelSBOBranchChangedBeyondL2v2",SWIG_From_int(static_cast< int >(ModelSBOBranchChangedBeyondL2v2)));
  SWIG_Python_SetConstant(d, "StrictUnitsRequiredInL2v2",SWIG_From_int(static_cast< int >(StrictUnitsRequiredInL2v2)));
  SWIG_Python_SetConstant(d, "StrictSBORequiredInL2v2",SWIG_From_int(static_cast< int >(StrictSBORequiredInL2v2)));
  SWIG_Python_SetConstant(d, "DuplicateAnnotationInvalidInL2v2",SWIG_From_int(static_cast< int >(DuplicateAnnotationInvalidInL2v2)));
  SWIG_Python_SetConstant(d, "NoUnitOffsetInL2v3",SWIG_From_int(static_cast< int >(NoUnitOffsetInL2v3)));
  SWIG_Python_SetConstant(d, "NoKineticLawTimeUnitsInL2v3",SWIG_From_int(static_cast< int >(NoKineticLawTimeUnitsInL2v3)));
  SWIG_Python_SetConstant(d, "NoKineticLawSubstanceUnitsInL2v3",SWIG_From_int(static_cast< int >(NoKineticLawSubstanceUnitsInL2v3)));
  SWIG_Python_SetConstant(d, "NoSpeciesSpatialSizeUnitsInL2v3",SWIG_From_int(static_cast< int >(NoSpeciesSpatialSizeUnitsInL2v3)));
  SWIG_Python_SetConstant(d, "NoEventTimeUnitsInL2v3",SWIG_From_int(static_cast< int >(NoEventTimeUnitsInL2v3)));
  SWIG_Python_SetConstant(d, "NoDelayedEventAssignmentInL2v3",SWIG_From_int(static_cast< int >(NoDelayedEventAssignmentInL2v3)));
  SWIG_Python_SetConstant(d, "ModelSBOBranchChangedBeyondL2v3",SWIG_From_int(static_cast< int >(ModelSBOBranchChangedBeyondL2v3)));
  SWIG_Python_SetConstant(d, "StrictUnitsRequiredInL2v3",SWIG_From_int(static_cast< int >(StrictUnitsRequiredInL2v3)));
  SWIG_Python_SetConstant(d, "StrictSBORequiredInL2v3",SWIG_From_int(static_cast< int >(StrictSBORequiredInL2v3)));
  SWIG_Python_SetConstant(d, "DuplicateAnnotationInvalidInL2v3",SWIG_From_int(static_cast< int >(DuplicateAnnotationInvalidInL2v3)));
  SWIG_Python_SetConstant(d, "NoUnitOffsetInL2v4",SWIG_From_int(static_cast< int >(NoUnitOffsetInL2v4)));
  SWIG_Python_SetConstant(d, "NoKineticLawTimeUnitsInL2v4",SWIG_From_int(static_cast< int >(NoKineticLawTimeUnitsInL2v4)));
  SWIG_Python_SetConstant(d, "NoKineticLawSubstanceUnitsInL2v4",SWIG_From_int(static_cast< int >(NoKineticLawSubstanceUnitsInL2v4)));
  SWIG_Python_SetConstant(d, "NoSpeciesSpatialSizeUnitsInL2v4",SWIG_From_int(static_cast< int >(NoSpeciesSpatialSizeUnitsInL2v4)));
  SWIG_Python_SetConstant(d, "NoEventTimeUnitsInL2v4",SWIG_From_int(static_cast< int >(NoEventTimeUnitsInL2v4)));
  SWIG_Python_SetConstant(d, "ModelSBOBranchChangedInL2v4",SWIG_From_int(static_cast< int >(ModelSBOBranchChangedInL2v4)));
  SWIG_Python_SetConstant(d, "DuplicateAnnotationInvalidInL2v4",SWIG_From_int(static_cast< int >(DuplicateAnnotationInvalidInL2v4)));
  SWIG_Python_SetConstant(d, "NoSpeciesTypeInL3v1",SWIG_From_int(static_cast< int >(NoSpeciesTypeInL3v1)));
  SWIG_Python_SetConstant(d, "NoCompartmentTypeInL3v1",SWIG_From_int(static_cast< int >(NoCompartmentTypeInL3v1)));
  SWIG_Python_SetConstant(d, "NoUnitOffsetInL3v1",SWIG_From_int(static_cast< int >(NoUnitOffsetInL3v1)));
  SWIG_Python_SetConstant(d, "NoKineticLawTimeUnitsInL3v1",SWIG_From_int(static_cast< int >(NoKineticLawTimeUnitsInL3v1)));
  SWIG_Python_SetConstant(d, "NoKineticLawSubstanceUnitsInL3v1",SWIG_From_int(static_cast< int >(NoKineticLawSubstanceUnitsInL3v1)));
  SWIG_Python_SetConstant(d, "NoSpeciesSpatialSizeUnitsInL3v1",SWIG_From_int(static_cast< int >(NoSpeciesSpatialSizeUnitsInL3v1)));
  SWIG_Python_SetConstant(d, "NoEventTimeUnitsInL3v1",SWIG_From_int(static_cast< int >(NoEventTimeUnitsInL3v1)));
  SWIG_Python_SetConstant(d, "ModelSBOBranchChangedInL3v1",SWIG_From_int(static_cast< int >(ModelSBOBranchChangedInL3v1)));
  SWIG_Python_SetConstant(d, "DuplicateAnnotationInvalidInL3v1",SWIG_From_int(static_cast< int >(DuplicateAnnotationInvalidInL3v1)));
  SWIG_Python_SetConstant(d, "NoCompartmentOutsideInL3v1",SWIG_From_int(static_cast< int >(NoCompartmentOutsideInL3v1)));
  SWIG_Python_SetConstant(d, "NoStoichiometryMathInL3v1",SWIG_From_int(static_cast< int >(NoStoichiometryMathInL3v1)));
  SWIG_Python_SetConstant(d, "DoubleExponentNotSupported",SWIG_From_int(static_cast< int >(DoubleExponentNotSupported)));
  SWIG_Python_SetConstant(d, "MathMLElementNotSupported",SWIG_From_int(static_cast< int >(MathMLElementNotSupported)));
  SWIG_Python_SetConstant(d, "EmptyListOfElementNotSupported",SWIG_From_int(static_cast< int >(EmptyListOfElementNotSupported)));
  SWIG_Python_SetConstant(d, "MissingMathElementNotSupported",SWIG_From_int(static_cast< int >(MissingMathElementNotSupported)));
  SWIG_Python_SetConstant(d, "MissingTriggerElementNotSupported",SWIG_From_int(static_cast< int >(MissingTriggerElementNotSupported)));
  SWIG_Python_SetConstant(d, "BooleanNumericDiscrepancy",SWIG_From_int(static_cast< int >(BooleanNumericDiscrepancy)));
  SWIG_Python_SetConstant(d, "IdNameSBaseInL3V2",SWIG_From_int(static_cast< int >(IdNameSBaseInL3V2)));
  SWIG_Python_SetConstant(d, "MissingParticipantsNotSupported",SWIG_From_int(static_cast< int >(MissingParticipantsNotSupported)));
  SWIG_Python_SetConstant(d, "ConvertibleMathInitialAssignment",SWIG_From_int(static_cast< int >(ConvertibleMathInitialAssignment)));
  SWIG_Python_SetConstant(d, "FastReactionsNotSupported",SWIG_From_int(static_cast< int >(FastReactionsNotSupported)));
  SWIG_Python_SetConstant(d, "SpeciesRefIdInMathMLNotSupported",SWIG_From_int(static_cast< int >(SpeciesRefIdInMathMLNotSupported)));
  SWIG_Python_SetConstant(d, "InvalidSBMLLevelVersion",SWIG_From_int(static_cast< int >(InvalidSBMLLevelVersion)));
  SWIG_Python_SetConstant(d, "InvalidPackageLevelVersion",SWIG_From_int(static_cast< int >(InvalidPackageLevelVersion)));
  SWIG_Python_SetConstant(d, "AnnotationNotesNotAllowedLevel1",SWIG_From_int(static_cast< int >(AnnotationNotesNotAllowedLevel1)));
  SWIG_Python_SetConstant(d, "InvalidRuleOrdering",SWIG_From_int(static_cast< int >(InvalidRuleOrdering)));
  SWIG_Python_SetConstant(d, "RequiredPackagePresent",SWIG_From_int(static_cast< int >(RequiredPackagePresent)));
  SWIG_Python_SetConstant(d, "UnrequiredPackagePresent",SWIG_From_int(static_cast< int >(UnrequiredPackagePresent)));
  SWIG_Python_SetConstant(d, "PackageRequiredShouldBeFalse",SWIG_From_int(static_cast< int >(PackageRequiredShouldBeFalse)));
  SWIG_Python_SetConstant(d, "SubsUnitsAllowedInKL",SWIG_From_int(static_cast< int >(SubsUnitsAllowedInKL)));
  SWIG_Python_SetConstant(d, "TimeUnitsAllowedInKL",SWIG_From_int(static_cast< int >(TimeUnitsAllowedInKL)));
  SWIG_Python_SetConstant(d, "FormulaInLevel1KL",SWIG_From_int(static_cast< int >(FormulaInLevel1KL)));
  SWIG_Python_SetConstant(d, "L3SubstanceUnitsOnModel",SWIG_From_int(static_cast< int >(L3SubstanceUnitsOnModel)));
  SWIG_Python_SetConstant(d, "StoichiometryMathMissingMath",SWIG_From_int(static_cast< int >(StoichiometryMathMissingMath)));
  SWIG_Python_SetConstant(d, "TimeUnitsRemoved",SWIG_From_int(static_cast< int >(TimeUnitsRemoved)));
  SWIG_Python_SetConstant(d, "BadMathML",SWIG_From_int(static_cast< int >(BadMathML)));
  SWIG_Python_SetConstant(d, "FailedMathMLReadOfDouble",SWIG_From_int(static_cast< int >(FailedMathMLReadOfDouble)));
  SWIG_Python_SetConstant(d, "FailedMathMLReadOfInteger",SWIG_From_int(static_cast< int >(FailedMathMLReadOfInteger)));
  SWIG_Python_SetConstant(d, "FailedMathMLReadOfExponential",SWIG_From_int(static_cast< int >(FailedMathMLReadOfExponential)));
  SWIG_Python_SetConstant(d, "FailedMathMLReadOfRational",SWIG_From_int(static_cast< int >(FailedMathMLReadOfRational)));
  SWIG_Python_SetConstant(d, "BadMathMLNodeType",SWIG_From_int(static_cast< int >(BadMathMLNodeType)));
  SWIG_Python_SetConstant(d, "InvalidMathMLAttribute",SWIG_From_int(static_cast< int >(InvalidMathMLAttribute)));
  SWIG_Python_SetConstant(d, "NoTimeSymbolInFunctionDef",SWIG_From_int(static_cast< int >(NoTimeSymbolInFunctionDef)));
  SWIG_Python_SetConstant(d, "NoBodyInFunctionDef",SWIG_From_int(static_cast< int >(NoBodyInFunctionDef)));
  SWIG_Python_SetConstant(d, "DanglingUnitSIdRef",SWIG_From_int(static_cast< int >(DanglingUnitSIdRef)));
  SWIG_Python_SetConstant(d, "RDFMissingAboutTag",SWIG_From_int(static_cast< int >(RDFMissingAboutTag)));
  SWIG_Python_SetConstant(d, "RDFEmptyAboutTag",SWIG_From_int(static_cast< int >(RDFEmptyAboutTag)));
  SWIG_Python_SetConstant(d, "RDFAboutTagNotMetaid",SWIG_From_int(static_cast< int >(RDFAboutTagNotMetaid)));
  SWIG_Python_SetConstant(d, "RDFNotCompleteModelHistory",SWIG_From_int(static_cast< int >(RDFNotCompleteModelHistory)));
  SWIG_Python_SetConstant(d, "RDFNotModelHistory",SWIG_From_int(static_cast< int >(RDFNotModelHistory)));
  SWIG_Python_SetConstant(d, "AnnotationNotElement",SWIG_From_int(static_cast< int >(AnnotationNotElement)));
  SWIG_Python_SetConstant(d, "NestedAnnotationNotAllowed",SWIG_From_int(static_cast< int >(NestedAnnotationNotAllowed)));
  SWIG_Python_SetConstant(d, "InconsistentArgUnitsWarnings",SWIG_From_int(static_cast< int >(InconsistentArgUnitsWarnings)));
  SWIG_Python_SetConstant(d, "InconsistentPowerUnitsWarnings",SWIG_From_int(static_cast< int >(InconsistentPowerUnitsWarnings)));
  SWIG_Python_SetConstant(d, "InconsistentExponUnitsWarnings",SWIG_From_int(static_cast< int >(InconsistentExponUnitsWarnings)));
  SWIG_Python_SetConstant(d, "UndeclaredUnits",SWIG_From_int(static_cast< int >(UndeclaredUnits)));
  SWIG_Python_SetConstant(d, "UndeclaredTimeUnitsL3",SWIG_From_int(static_cast< int >(UndeclaredTimeUnitsL3)));
  SWIG_Python_SetConstant(d, "UndeclaredExtentUnitsL3",SWIG_From_int(static_cast< int >(UndeclaredExtentUnitsL3)));
  SWIG_Python_SetConstant(d, "UndeclaredObjectUnitsL3",SWIG_From_int(static_cast< int >(UndeclaredObjectUnitsL3)));
  SWIG_Python_SetConstant(d, "CannotVerifyUnitsObjectNoMath",SWIG_From_int(static_cast< int >(CannotVerifyUnitsObjectNoMath)));
  SWIG_Python_SetConstant(d, "UnrecognisedSBOTerm",SWIG_From_int(static_cast< int >(UnrecognisedSBOTerm)));
  SWIG_Python_SetConstant(d, "ObseleteSBOTerm",SWIG_From_int(static_cast< int >(ObseleteSBOTerm)));
  SWIG_Python_SetConstant(d, "IncorrectCompartmentSpatialDimensions",SWIG_From_int(static_cast< int >(IncorrectCompartmentSpatialDimensions)));
  SWIG_Python_SetConstant(d, "CompartmentTypeNotValidAttribute",SWIG_From_int(static_cast< int >(CompartmentTypeNotValidAttribute)));
  SWIG_Python_SetConstant(d, "ConstantNotValidAttribute",SWIG_From_int(static_cast< int >(ConstantNotValidAttribute)));
  SWIG_Python_SetConstant(d, "MetaIdNotValidAttribute",SWIG_From_int(static_cast< int >(MetaIdNotValidAttribute)));
  SWIG_Python_SetConstant(d, "SBOTermNotValidAttributeBeforeL2V3",SWIG_From_int(static_cast< int >(SBOTermNotValidAttributeBeforeL2V3)));
  SWIG_Python_SetConstant(d, "InvalidL1CompartmentUnits",SWIG_From_int(static_cast< int >(InvalidL1CompartmentUnits)));
  SWIG_Python_SetConstant(d, "L1V1CompartmentVolumeReqd",SWIG_From_int(static_cast< int >(L1V1CompartmentVolumeReqd)));
  SWIG_Python_SetConstant(d, "CompartmentTypeNotValidComponent",SWIG_From_int(static_cast< int >(CompartmentTypeNotValidComponent)));
  SWIG_Python_SetConstant(d, "ConstraintNotValidComponent",SWIG_From_int(static_cast< int >(ConstraintNotValidComponent)));
  SWIG_Python_SetConstant(d, "EventNotValidComponent",SWIG_From_int(static_cast< int >(EventNotValidComponent)));
  SWIG_Python_SetConstant(d, "SBOTermNotValidAttributeBeforeL2V2",SWIG_From_int(static_cast< int >(SBOTermNotValidAttributeBeforeL2V2)));
  SWIG_Python_SetConstant(d, "FuncDefNotValidComponent",SWIG_From_int(static_cast< int >(FuncDefNotValidComponent)));
  SWIG_Python_SetConstant(d, "InitialAssignNotValidComponent",SWIG_From_int(static_cast< int >(InitialAssignNotValidComponent)));
  SWIG_Python_SetConstant(d, "VariableNotValidAttribute",SWIG_From_int(static_cast< int >(VariableNotValidAttribute)));
  SWIG_Python_SetConstant(d, "UnitsNotValidAttribute",SWIG_From_int(static_cast< int >(UnitsNotValidAttribute)));
  SWIG_Python_SetConstant(d, "ConstantSpeciesNotValidAttribute",SWIG_From_int(static_cast< int >(ConstantSpeciesNotValidAttribute)));
  SWIG_Python_SetConstant(d, "SpatialSizeUnitsNotValidAttribute",SWIG_From_int(static_cast< int >(SpatialSizeUnitsNotValidAttribute)));
  SWIG_Python_SetConstant(d, "SpeciesTypeNotValidAttribute",SWIG_From_int(static_cast< int >(SpeciesTypeNotValidAttribute)));
  SWIG_Python_SetConstant(d, "HasOnlySubsUnitsNotValidAttribute",SWIG_From_int(static_cast< int >(HasOnlySubsUnitsNotValidAttribute)));
  SWIG_Python_SetConstant(d, "IdNotValidAttribute",SWIG_From_int(static_cast< int >(IdNotValidAttribute)));
  SWIG_Python_SetConstant(d, "NameNotValidAttribute",SWIG_From_int(static_cast< int >(NameNotValidAttribute)));
  SWIG_Python_SetConstant(d, "SpeciesTypeNotValidComponent",SWIG_From_int(static_cast< int >(SpeciesTypeNotValidComponent)));
  SWIG_Python_SetConstant(d, "StoichiometryMathNotValidComponent",SWIG_From_int(static_cast< int >(StoichiometryMathNotValidComponent)));
  SWIG_Python_SetConstant(d, "MultiplierNotValidAttribute",SWIG_From_int(static_cast< int >(MultiplierNotValidAttribute)));
  SWIG_Python_SetConstant(d, "OffsetNotValidAttribute",SWIG_From_int(static_cast< int >(OffsetNotValidAttribute)));
  SWIG_Python_SetConstant(d, "L3SpatialDimensionsUnset",SWIG_From_int(static_cast< int >(L3SpatialDimensionsUnset)));
  SWIG_Python_SetConstant(d, "OperationInterrupted",SWIG_From_int(static_cast< int >(OperationInterrupted)));
  SWIG_Python_SetConstant(d, "UnknownCoreAttribute",SWIG_From_int(static_cast< int >(UnknownCoreAttribute)));
  SWIG_Python_SetConstant(d, "UnknownPackageAttribute",SWIG_From_int(static_cast< int >(UnknownPackageAttribute)));
  SWIG_Python_SetConstant(d, "PackageConversionNotSupported",SWIG_From_int(static_cast< int >(PackageConversionNotSupported)));
  SWIG_Python_SetConstant(d, "InvalidTargetLevelVersion",SWIG_From_int(static_cast< int >(InvalidTargetLevelVersion)));
  SWIG_Python_SetConstant(d, "L3NotSupported",SWIG_From_int(static_cast< int >(L3NotSupported)));
  SWIG_Python_SetConstant(d, "SBMLCodesUpperBound",SWIG_From_int(static_cast< int >(SBMLCodesUpperBound)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_SBML",SWIG_From_int(static_cast< int >(LIBSBML_CAT_SBML)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_SBML_L1_COMPAT",SWIG_From_int(static_cast< int >(LIBSBML_CAT_SBML_L1_COMPAT)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_SBML_L2V1_COMPAT",SWIG_From_int(static_cast< int >(LIBSBML_CAT_SBML_L2V1_COMPAT)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_SBML_L2V2_COMPAT",SWIG_From_int(static_cast< int >(LIBSBML_CAT_SBML_L2V2_COMPAT)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_GENERAL_CONSISTENCY",SWIG_From_int(static_cast< int >(LIBSBML_CAT_GENERAL_CONSISTENCY)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_IDENTIFIER_CONSISTENCY",SWIG_From_int(static_cast< int >(LIBSBML_CAT_IDENTIFIER_CONSISTENCY)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_UNITS_CONSISTENCY",SWIG_From_int(static_cast< int >(LIBSBML_CAT_UNITS_CONSISTENCY)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_MATHML_CONSISTENCY",SWIG_From_int(static_cast< int >(LIBSBML_CAT_MATHML_CONSISTENCY)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_SBO_CONSISTENCY",SWIG_From_int(static_cast< int >(LIBSBML_CAT_SBO_CONSISTENCY)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_OVERDETERMINED_MODEL",SWIG_From_int(static_cast< int >(LIBSBML_CAT_OVERDETERMINED_MODEL)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_SBML_L2V3_COMPAT",SWIG_From_int(static_cast< int >(LIBSBML_CAT_SBML_L2V3_COMPAT)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_MODELING_PRACTICE",SWIG_From_int(static_cast< int >(LIBSBML_CAT_MODELING_PRACTICE)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_INTERNAL_CONSISTENCY",SWIG_From_int(static_cast< int >(LIBSBML_CAT_INTERNAL_CONSISTENCY)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_SBML_L2V4_COMPAT",SWIG_From_int(static_cast< int >(LIBSBML_CAT_SBML_L2V4_COMPAT)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_SBML_L3V1_COMPAT",SWIG_From_int(static_cast< int >(LIBSBML_CAT_SBML_L3V1_COMPAT)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_SBML_L3V2_COMPAT",SWIG_From_int(static_cast< int >(LIBSBML_CAT_SBML_L3V2_COMPAT)));
  SWIG_Python_SetConstant(d, "LIBSBML_CAT_SBML_COMPATIBILITY",SWIG_From_int(static_cast< int >(LIBSBML_CAT_SBML_COMPATIBILITY)));
  SWIG_Python_SetConstant(d, "LIBSBML_SEV_SCHEMA_ERROR",SWIG_From_int(static_cast< int >(LIBSBML_SEV_SCHEMA_ERROR)));
  SWIG_Python_SetConstant(d, "LIBSBML_SEV_GENERAL_WARNING",SWIG_From_int(static_cast< int >(LIBSBML_SEV_GENERAL_WARNING)));
  SWIG_Python_SetConstant(d, "LIBSBML_SEV_NOT_APPLICABLE",SWIG_From_int(static_cast< int >(LIBSBML_SEV_NOT_APPLICABLE)));
  SWIG_Python_SetConstant(d, "LIBSBML_SEV_UNKNOWN",SWIG_From_int(static_cast< int >(LIBSBML_SEV_UNKNOWN)));
  SWIG_Python_SetConstant(d, "MODEL_QUALIFIER",SWIG_From_int(static_cast< int >(MODEL_QUALIFIER)));
  SWIG_Python_SetConstant(d, "BIOLOGICAL_QUALIFIER",SWIG_From_int(static_cast< int >(BIOLOGICAL_QUALIFIER)));
  SWIG_Python_SetConstant(d, "UNKNOWN_QUALIFIER",SWIG_From_int(static_cast< int >(UNKNOWN_QUALIFIER)));
  SWIG_Python_SetConstant(d, "BQM_IS",SWIG_From_int(static_cast< int >(BQM_IS)));
  SWIG_Python_SetConstant(d, "BQM_IS_DESCRIBED_BY",SWIG_From_int(static_cast< int >(BQM_IS_DESCRIBED_BY)));
  SWIG_Python_SetConstant(d, "BQM_IS_DERIVED_FROM",SWIG_From_int(static_cast< int >(BQM_IS_DERIVED_FROM)));
  SWIG_Python_SetConstant(d, "BQM_IS_INSTANCE_OF",SWIG_From_int(static_cast< int >(BQM_IS_INSTANCE_OF)));
  SWIG_Python_SetConstant(d, "BQM_HAS_INSTANCE",SWIG_From_int(static_cast< int >(BQM_HAS_INSTANCE)));
  SWIG_Python_SetConstant(d, "BQM_UNKNOWN",SWIG_From_int(static_cast< int >(BQM_UNKNOWN)));
  SWIG_Python_SetConstant(d, "BQB_IS",SWIG_From_int(static_cast< int >(BQB_IS)));
  SWIG_Python_SetConstant(d, "BQB_HAS_PART",SWIG_From_int(static_cast< int >(BQB_HAS_PART)));
  SWIG_Python_SetConstant(d, "BQB_IS_PART_OF",SWIG_From_int(static_cast< int >(BQB_IS_PART_OF)));
  SWIG_Python_SetConstant(d, "BQB_IS_VERSION_OF",SWIG_From_int(static_cast< int >(BQB_IS_VERSION_OF)));
  SWIG_Python_SetConstant(d, "BQB_HAS_VERSION",SWIG_From_int(static_cast< int >(BQB_HAS_VERSION)));
  SWIG_Python_SetConstant(d, "BQB_IS_HOMOLOG_TO",SWIG_From_int(static_cast< int >(BQB_IS_HOMOLOG_TO)));
  SWIG_Python_SetConstant(d, "BQB_IS_DESCRIBED_BY",SWIG_From_int(static_cast< int >(BQB_IS_DESCRIBED_BY)));
  SWIG_Python_SetConstant(d, "BQB_IS_ENCODED_BY",SWIG_From_int(static_cast< int >(BQB_IS_ENCODED_BY)));
  SWIG_Python_SetConstant(d, "BQB_ENCODES",SWIG_From_int(static_cast< int >(BQB_ENCODES)));
  SWIG_Python_SetConstant(d, "BQB_OCCURS_IN",SWIG_From_int(static_cast< int >(BQB_OCCURS_IN)));
  SWIG_Python_SetConstant(d, "BQB_HAS_PROPERTY",SWIG_From_int(static_cast< int >(BQB_HAS_PROPERTY)));
  SWIG_Python_SetConstant(d, "BQB_IS_PROPERTY_OF",SWIG_From_int(static_cast< int >(BQB_IS_PROPERTY_OF)));
  SWIG_Python_SetConstant(d, "BQB_HAS_TAXON",SWIG_From_int(static_cast< int >(BQB_HAS_TAXON)));
  SWIG_Python_SetConstant(d, "BQB_UNKNOWN",SWIG_From_int(static_cast< int >(BQB_UNKNOWN)));
  SWIG_Python_SetConstant(d, "EM_L3V2",SWIG_From_int(static_cast< int >(EM_L3V2)));
  SWIG_Python_SetConstant(d, "EM_DISTRIB",SWIG_From_int(static_cast< int >(EM_DISTRIB)));
  SWIG_Python_SetConstant(d, "EM_ARRAYS",SWIG_From_int(static_cast< int >(EM_ARRAYS)));
  SWIG_Python_SetConstant(d, "EM_REMAINING",SWIG_From_int(static_cast< int >(EM_REMAINING)));
  SWIG_Python_SetConstant(d, "EM_UNKNOWN",SWIG_From_int(static_cast< int >(EM_UNKNOWN)));
  SWIG_Python_SetConstant(d, "ALLOWED_CHILDREN_ANY",SWIG_From_int(static_cast< int >(ALLOWED_CHILDREN_ANY)));
  SWIG_Python_SetConstant(d, "ALLOWED_CHILDREN_ATLEAST",SWIG_From_int(static_cast< int >(ALLOWED_CHILDREN_ATLEAST)));
  SWIG_Python_SetConstant(d, "ALLOWED_CHILDREN_EXACTLY",SWIG_From_int(static_cast< int >(ALLOWED_CHILDREN_EXACTLY)));
  SWIG_Python_SetConstant(d, "ALLOWED_CHILDREN_UNKNOWN",SWIG_From_int(static_cast< int >(ALLOWED_CHILDREN_UNKNOWN)));
  SWIG_Python_SetConstant(d, "AST_PLUS",SWIG_From_int(static_cast< int >(AST_PLUS)));
  SWIG_Python_SetConstant(d, "AST_MINUS",SWIG_From_int(static_cast< int >(AST_MINUS)));
  SWIG_Python_SetConstant(d, "AST_TIMES",SWIG_From_int(static_cast< int >(AST_TIMES)));
  SWIG_Python_SetConstant(d, "AST_DIVIDE",SWIG_From_int(static_cast< int >(AST_DIVIDE)));
  SWIG_Python_SetConstant(d, "AST_POWER",SWIG_From_int(static_cast< int >(AST_POWER)));
  SWIG_Python_SetConstant(d, "AST_INTEGER",SWIG_From_int(static_cast< int >(AST_INTEGER)));
  SWIG_Python_SetConstant(d, "AST_REAL",SWIG_From_int(static_cast< int >(AST_REAL)));
  SWIG_Python_SetConstant(d, "AST_REAL_E",SWIG_From_int(static_cast< int >(AST_REAL_E)));
  SWIG_Python_SetConstant(d, "AST_RATIONAL",SWIG_From_int(static_cast< int >(AST_RATIONAL)));
  SWIG_Python_SetConstant(d, "AST_NAME",SWIG_From_int(static_cast< int >(AST_NAME)));
  SWIG_Python_SetConstant(d, "AST_NAME_AVOGADRO",SWIG_From_int(static_cast< int >(AST_NAME_AVOGADRO)));
  SWIG_Python_SetConstant(d, "AST_NAME_TIME",SWIG_From_int(static_cast< int >(AST_NAME_TIME)));
  SWIG_Python_SetConstant(d, "AST_CONSTANT_E",SWIG_From_int(static_cast< int >(AST_CONSTANT_E)));
  SWIG_Python_SetConstant(d, "AST_CONSTANT_FALSE",SWIG_From_int(static_cast< int >(AST_CONSTANT_FALSE)));
  SWIG_Python_SetConstant(d, "AST_CONSTANT_PI",SWIG_From_int(static_cast< int >(AST_CONSTANT_PI)));
  SWIG_Python_SetConstant(d, "AST_CONSTANT_TRUE",SWIG_From_int(static_cast< int >(AST_CONSTANT_TRUE)));
  SWIG_Python_SetConstant(d, "AST_LAMBDA",SWIG_From_int(static_cast< int >(AST_LAMBDA)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION",SWIG_From_int(static_cast< int >(AST_FUNCTION)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ABS",SWIG_From_int(static_cast< int >(AST_FUNCTION_ABS)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ARCCOS",SWIG_From_int(static_cast< int >(AST_FUNCTION_ARCCOS)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ARCCOSH",SWIG_From_int(static_cast< int >(AST_FUNCTION_ARCCOSH)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ARCCOT",SWIG_From_int(static_cast< int >(AST_FUNCTION_ARCCOT)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ARCCOTH",SWIG_From_int(static_cast< int >(AST_FUNCTION_ARCCOTH)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ARCCSC",SWIG_From_int(static_cast< int >(AST_FUNCTION_ARCCSC)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ARCCSCH",SWIG_From_int(static_cast< int >(AST_FUNCTION_ARCCSCH)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ARCSEC",SWIG_From_int(static_cast< int >(AST_FUNCTION_ARCSEC)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ARCSECH",SWIG_From_int(static_cast< int >(AST_FUNCTION_ARCSECH)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ARCSIN",SWIG_From_int(static_cast< int >(AST_FUNCTION_ARCSIN)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ARCSINH",SWIG_From_int(static_cast< int >(AST_FUNCTION_ARCSINH)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ARCTAN",SWIG_From_int(static_cast< int >(AST_FUNCTION_ARCTAN)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ARCTANH",SWIG_From_int(static_cast< int >(AST_FUNCTION_ARCTANH)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_CEILING",SWIG_From_int(static_cast< int >(AST_FUNCTION_CEILING)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_COS",SWIG_From_int(static_cast< int >(AST_FUNCTION_COS)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_COSH",SWIG_From_int(static_cast< int >(AST_FUNCTION_COSH)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_COT",SWIG_From_int(static_cast< int >(AST_FUNCTION_COT)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_COTH",SWIG_From_int(static_cast< int >(AST_FUNCTION_COTH)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_CSC",SWIG_From_int(static_cast< int >(AST_FUNCTION_CSC)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_CSCH",SWIG_From_int(static_cast< int >(AST_FUNCTION_CSCH)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_DELAY",SWIG_From_int(static_cast< int >(AST_FUNCTION_DELAY)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_EXP",SWIG_From_int(static_cast< int >(AST_FUNCTION_EXP)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_FACTORIAL",SWIG_From_int(static_cast< int >(AST_FUNCTION_FACTORIAL)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_FLOOR",SWIG_From_int(static_cast< int >(AST_FUNCTION_FLOOR)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_LN",SWIG_From_int(static_cast< int >(AST_FUNCTION_LN)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_LOG",SWIG_From_int(static_cast< int >(AST_FUNCTION_LOG)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_PIECEWISE",SWIG_From_int(static_cast< int >(AST_FUNCTION_PIECEWISE)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_POWER",SWIG_From_int(static_cast< int >(AST_FUNCTION_POWER)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_ROOT",SWIG_From_int(static_cast< int >(AST_FUNCTION_ROOT)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_SEC",SWIG_From_int(static_cast< int >(AST_FUNCTION_SEC)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_SECH",SWIG_From_int(static_cast< int >(AST_FUNCTION_SECH)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_SIN",SWIG_From_int(static_cast< int >(AST_FUNCTION_SIN)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_SINH",SWIG_From_int(static_cast< int >(AST_FUNCTION_SINH)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_TAN",SWIG_From_int(static_cast< int >(AST_FUNCTION_TAN)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_TANH",SWIG_From_int(static_cast< int >(AST_FUNCTION_TANH)));
  SWIG_Python_SetConstant(d, "AST_LOGICAL_AND",SWIG_From_int(static_cast< int >(AST_LOGICAL_AND)));
  SWIG_Python_SetConstant(d, "AST_LOGICAL_NOT",SWIG_From_int(static_cast< int >(AST_LOGICAL_NOT)));
  SWIG_Python_SetConstant(d, "AST_LOGICAL_OR",SWIG_From_int(static_cast< int >(AST_LOGICAL_OR)));
  SWIG_Python_SetConstant(d, "AST_LOGICAL_XOR",SWIG_From_int(static_cast< int >(AST_LOGICAL_XOR)));
  SWIG_Python_SetConstant(d, "AST_RELATIONAL_EQ",SWIG_From_int(static_cast< int >(AST_RELATIONAL_EQ)));
  SWIG_Python_SetConstant(d, "AST_RELATIONAL_GEQ",SWIG_From_int(static_cast< int >(AST_RELATIONAL_GEQ)));
  SWIG_Python_SetConstant(d, "AST_RELATIONAL_GT",SWIG_From_int(static_cast< int >(AST_RELATIONAL_GT)));
  SWIG_Python_SetConstant(d, "AST_RELATIONAL_LEQ",SWIG_From_int(static_cast< int >(AST_RELATIONAL_LEQ)));
  SWIG_Python_SetConstant(d, "AST_RELATIONAL_LT",SWIG_From_int(static_cast< int >(AST_RELATIONAL_LT)));
  SWIG_Python_SetConstant(d, "AST_RELATIONAL_NEQ",SWIG_From_int(static_cast< int >(AST_RELATIONAL_NEQ)));
  SWIG_Python_SetConstant(d, "AST_END_OF_CORE",SWIG_From_int(static_cast< int >(AST_END_OF_CORE)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_MAX",SWIG_From_int(static_cast< int >(AST_FUNCTION_MAX)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_MIN",SWIG_From_int(static_cast< int >(AST_FUNCTION_MIN)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_QUOTIENT",SWIG_From_int(static_cast< int >(AST_FUNCTION_QUOTIENT)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_RATE_OF",SWIG_From_int(static_cast< int >(AST_FUNCTION_RATE_OF)));
  SWIG_Python_SetConstant(d, "AST_FUNCTION_REM",SWIG_From_int(static_cast< int >(AST_FUNCTION_REM)));
  SWIG_Python_SetConstant(d, "AST_LOGICAL_IMPLIES",SWIG_From_int(static_cast< int >(AST_LOGICAL_IMPLIES)));
  SWIG_Python_SetConstant(d, "AST_CSYMBOL_FUNCTION",SWIG_From_int(static_cast< int >(AST_CSYMBOL_FUNCTION)));
  SWIG_Python_SetConstant(d, "AST_DISTRIB_FUNCTION_NORMAL",SWIG_From_int(static_cast< int >(AST_DISTRIB_FUNCTION_NORMAL)));
  SWIG_Python_SetConstant(d, "AST_DISTRIB_FUNCTION_UNIFORM",SWIG_From_int(static_cast< int >(AST_DISTRIB_FUNCTION_UNIFORM)));
  SWIG_Python_SetConstant(d, "AST_DISTRIB_FUNCTION_BERNOULLI",SWIG_From_int(static_cast< int >(AST_DISTRIB_FUNCTION_BERNOULLI)));
  SWIG_Python_SetConstant(d, "AST_DISTRIB_FUNCTION_BINOMIAL",SWIG_From_int(static_cast< int >(AST_DISTRIB_FUNCTION_BINOMIAL)));
  SWIG_Python_SetConstant(d, "AST_DISTRIB_FUNCTION_CAUCHY",SWIG_From_int(static_cast< int >(AST_DISTRIB_FUNCTION_CAUCHY)));
  SWIG_Python_SetConstant(d, "AST_DISTRIB_FUNCTION_CHISQUARE",SWIG_From_int(static_cast< int >(AST_DISTRIB_FUNCTION_CHISQUARE)));
  SWIG_Python_SetConstant(d, "AST_DISTRIB_FUNCTION_EXPONENTIAL",SWIG_From_int(static_cast< int >(AST_DISTRIB_FUNCTION_EXPONENTIAL)));
  SWIG_Python_SetConstant(d, "AST_DISTRIB_FUNCTION_GAMMA",SWIG_From_int(static_cast< int >(AST_DISTRIB_FUNCTION_GAMMA)));
  SWIG_Python_SetConstant(d, "AST_DISTRIB_FUNCTION_LAPLACE",SWIG_From_int(static_cast< int >(AST_DISTRIB_FUNCTION_LAPLACE)));
  SWIG_Python_SetConstant(d, "AST_DISTRIB_FUNCTION_LOGNORMAL",SWIG_From_int(static_cast< int >(AST_DISTRIB_FUNCTION_LOGNORMAL)));
  SWIG_Python_SetConstant(d, "AST_DISTRIB_FUNCTION_POISSON",SWIG_From_int(static_cast< int >(AST_DISTRIB_FUNCTION_POISSON)));
  SWIG_Python_SetConstant(d, "AST_DISTRIB_FUNCTION_RAYLEIGH",SWIG_From_int(static_cast< int >(AST_DISTRIB_FUNCTION_RAYLEIGH)));
  SWIG_Python_SetConstant(d, "AST_LINEAR_ALGEBRA_VECTOR",SWIG_From_int(static_cast< int >(AST_LINEAR_ALGEBRA_VECTOR)));
  SWIG_Python_SetConstant(d, "AST_LINEAR_ALGEBRA_SELECTOR",SWIG_From_int(static_cast< int >(AST_LINEAR_ALGEBRA_SELECTOR)));
  SWIG_Python_SetConstant(d, "AST_LINEAR_ALGEBRA_MATRIX",SWIG_From_int(static_cast< int >(AST_LINEAR_ALGEBRA_MATRIX)));
  SWIG_Python_SetConstant(d, "AST_LINEAR_ALGEBRA_MATRIXROW",SWIG_From_int(static_cast< int >(AST_LINEAR_ALGEBRA_MATRIXROW)));
  SWIG_Python_SetConstant(d, "AST_LINEAR_ALGEBRA_DETERMINANT",SWIG_From_int(static_cast< int >(AST_LINEAR_ALGEBRA_DETERMINANT)));
  SWIG_Python_SetConstant(d, "AST_LINEAR_ALGEBRA_TRANSPOSE",SWIG_From_int(static_cast< int >(AST_LINEAR_ALGEBRA_TRANSPOSE)));
  SWIG_Python_SetConstant(d, "AST_LINEAR_ALGEBRA_VECTOR_PRODUCT",SWIG_From_int(static_cast< int >(AST_LINEAR_ALGEBRA_VECTOR_PRODUCT)));
  SWIG_Python_SetConstant(d, "AST_LINEAR_ALGEBRA_SCALAR_PRODUCT",SWIG_From_int(static_cast< int >(AST_LINEAR_ALGEBRA_SCALAR_PRODUCT)));
  SWIG_Python_SetConstant(d, "AST_LINEAR_ALGEBRA_OUTER_PRODUCT",SWIG_From_int(static_cast< int >(AST_LINEAR_ALGEBRA_OUTER_PRODUCT)));
  SWIG_Python_SetConstant(d, "AST_LOGICAL_EXISTS",SWIG_From_int(static_cast< int >(AST_LOGICAL_EXISTS)));
  SWIG_Python_SetConstant(d, "AST_LOGICAL_FORALL",SWIG_From_int(static_cast< int >(AST_LOGICAL_FORALL)));
  SWIG_Python_SetConstant(d, "AST_STATISTICS_MEAN",SWIG_From_int(static_cast< int >(AST_STATISTICS_MEAN)));
  SWIG_Python_SetConstant(d, "AST_STATISTICS_MEDIAN",SWIG_From_int(static_cast< int >(AST_STATISTICS_MEDIAN)));
  SWIG_Python_SetConstant(d, "AST_STATISTICS_MODE",SWIG_From_int(static_cast< int >(AST_STATISTICS_MODE)));
  SWIG_Python_SetConstant(d, "AST_STATISTICS_MOMENT",SWIG_From_int(static_cast< int >(AST_STATISTICS_MOMENT)));
  SWIG_Python_SetConstant(d, "AST_STATISTICS_SDEV",SWIG_From_int(static_cast< int >(AST_STATISTICS_SDEV)));
  SWIG_Python_SetConstant(d, "AST_STATISTICS_VARIANCE",SWIG_From_int(static_cast< int >(AST_STATISTICS_VARIANCE)));
  SWIG_Python_SetConstant(d, "AST_STATISTICS_MOMENTABOUT",SWIG_From_int(static_cast< int >(AST_STATISTICS_MOMENTABOUT)));
  SWIG_Python_SetConstant(d, "AST_SERIES_PRODUCT",SWIG_From_int(static_cast< int >(AST_SERIES_PRODUCT)));
  SWIG_Python_SetConstant(d, "AST_SERIES_SUM",SWIG_From_int(static_cast< int >(AST_SERIES_SUM)));
  SWIG_Python_SetConstant(d, "AST_SERIES_LIMIT",SWIG_From_int(static_cast< int >(AST_SERIES_LIMIT)));
  SWIG_Python_SetConstant(d, "AST_SERIES_TENDSTO",SWIG_From_int(static_cast< int >(AST_SERIES_TENDSTO)));
  SWIG_Python_SetConstant(d, "AST_ALGEBRA_GCD",SWIG_From_int(static_cast< int >(AST_ALGEBRA_GCD)));
  SWIG_Python_SetConstant(d, "AST_ALGEBRA_CONJUGATE",SWIG_From_int(static_cast< int >(AST_ALGEBRA_CONJUGATE)));
  SWIG_Python_SetConstant(d, "AST_ALGEBRA_ARG",SWIG_From_int(static_cast< int >(AST_ALGEBRA_ARG)));
  SWIG_Python_SetConstant(d, "AST_ALGEBRA_REAL",SWIG_From_int(static_cast< int >(AST_ALGEBRA_REAL)));
  SWIG_Python_SetConstant(d, "AST_ALGEBRA_IMAGINARY",SWIG_From_int(static_cast< int >(AST_ALGEBRA_IMAGINARY)));
  SWIG_Python_SetConstant(d, "AST_ALGEBRA_LCM",SWIG_From_int(static_cast< int >(AST_ALGEBRA_LCM)));
  SWIG_Python_SetConstant(d, "AST_RELATIONS_EQUIVALENT",SWIG_From_int(static_cast< int >(AST_RELATIONS_EQUIVALENT)));
  SWIG_Python_SetConstant(d, "AST_RELATIONS_APPROX",SWIG_From_int(static_cast< int >(AST_RELATIONS_APPROX)));
  SWIG_Python_SetConstant(d, "AST_RELATIONS_FACTOROF",SWIG_From_int(static_cast< int >(AST_RELATIONS_FACTOROF)));
  SWIG_Python_SetConstant(d, "AST_CALCULUS_INT",SWIG_From_int(static_cast< int >(AST_CALCULUS_INT)));
  SWIG_Python_SetConstant(d, "AST_CALCULUS_DIFF",SWIG_From_int(static_cast< int >(AST_CALCULUS_DIFF)));
  SWIG_Python_SetConstant(d, "AST_CALCULUS_PARTIALDIFF",SWIG_From_int(static_cast< int >(AST_CALCULUS_PARTIALDIFF)));
  SWIG_Python_SetConstant(d, "AST_CALCULUS_LOWLIMIT",SWIG_From_int(static_cast< int >(AST_CALCULUS_LOWLIMIT)));
  SWIG_Python_SetConstant(d, "AST_CALCULUS_UPLIMIT",SWIG_From_int(static_cast< int >(AST_CALCULUS_UPLIMIT)));
  SWIG_Python_SetConstant(d, "AST_CALCULUS_DIVERGENCE",SWIG_From_int(static_cast< int >(AST_CALCULUS_DIVERGENCE)));
  SWIG_Python_SetConstant(d, "AST_CALCULUS_GRAD",SWIG_From_int(static_cast< int >(AST_CALCULUS_GRAD)));
  SWIG_Python_SetConstant(d, "AST_CALCULUS_CURL",SWIG_From_int(static_cast< int >(AST_CALCULUS_CURL)));
  SWIG_Python_SetConstant(d, "AST_CALCULUS_LAPLACIAN",SWIG_From_int(static_cast< int >(AST_CALCULUS_LAPLACIAN)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_SET",SWIG_From_int(static_cast< int >(AST_SET_THEORY_SET)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_LIST",SWIG_From_int(static_cast< int >(AST_SET_THEORY_LIST)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_UNION",SWIG_From_int(static_cast< int >(AST_SET_THEORY_UNION)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_INTERSECT",SWIG_From_int(static_cast< int >(AST_SET_THEORY_INTERSECT)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_IN",SWIG_From_int(static_cast< int >(AST_SET_THEORY_IN)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_NOTIN",SWIG_From_int(static_cast< int >(AST_SET_THEORY_NOTIN)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_SUBSET",SWIG_From_int(static_cast< int >(AST_SET_THEORY_SUBSET)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_PRSUBSET",SWIG_From_int(static_cast< int >(AST_SET_THEORY_PRSUBSET)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_NOTSUBSET",SWIG_From_int(static_cast< int >(AST_SET_THEORY_NOTSUBSET)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_NOTPRSUBSET",SWIG_From_int(static_cast< int >(AST_SET_THEORY_NOTPRSUBSET)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_SETDIFF",SWIG_From_int(static_cast< int >(AST_SET_THEORY_SETDIFF)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_CARD",SWIG_From_int(static_cast< int >(AST_SET_THEORY_CARD)));
  SWIG_Python_SetConstant(d, "AST_SET_THEORY_CARTESIANPRODUCT",SWIG_From_int(static_cast< int >(AST_SET_THEORY_CARTESIANPRODUCT)));
  SWIG_Python_SetConstant(d, "AST_CONSTANT_IMAGINARYI",SWIG_From_int(static_cast< int >(AST_CONSTANT_IMAGINARYI)));
  SWIG_Python_SetConstant(d, "AST_CONSTANTS_INTEGERS",SWIG_From_int(static_cast< int >(AST_CONSTANTS_INTEGERS)));
  SWIG_Python_SetConstant(d, "AST_CONSTANTS_REALS",SWIG_From_int(static_cast< int >(AST_CONSTANTS_REALS)));
  SWIG_Python_SetConstant(d, "AST_CONSTANTS_RATIONALS",SWIG_From_int(static_cast< int >(AST_CONSTANTS_RATIONALS)));
  SWIG_Python_SetConstant(d, "AST_CONSTANTS_NATURALNUMBERS",SWIG_From_int(static_cast< int >(AST_CONSTANTS_NATURALNUMBERS)));
  SWIG_Python_SetConstant(d, "AST_CONSTANTS_COMPLEXES",SWIG_From_int(static_cast< int >(AST_CONSTANTS_COMPLEXES)));
  SWIG_Python_SetConstant(d, "AST_CONSTANTS_PRIMES",SWIG_From_int(static_cast< int >(AST_CONSTANTS_PRIMES)));
  SWIG_Python_SetConstant(d, "AST_CONSTANTS_EMPTYSET",SWIG_From_int(static_cast< int >(AST_CONSTANTS_EMPTYSET)));
  SWIG_Python_SetConstant(d, "AST_CONSTANTS_EULERGAMMA",SWIG_From_int(static_cast< int >(AST_CONSTANTS_EULERGAMMA)));
  SWIG_Python_SetConstant(d, "AST_BASIC_CONTENT_INTERVAL",SWIG_From_int(static_cast< int >(AST_BASIC_CONTENT_INTERVAL)));
  SWIG_Python_SetConstant(d, "AST_BASIC_CONTENT_INVERSE",SWIG_From_int(static_cast< int >(AST_BASIC_CONTENT_INVERSE)));
  SWIG_Python_SetConstant(d, "AST_BASIC_CONTENT_CONDITION",SWIG_From_int(static_cast< int >(AST_BASIC_CONTENT_CONDITION)));
  SWIG_Python_SetConstant(d, "AST_BASIC_CONTENT_DECLARE",SWIG_From_int(static_cast< int >(AST_BASIC_CONTENT_DECLARE)));
  SWIG_Python_SetConstant(d, "AST_BASIC_CONTENT_COMPOSE",SWIG_From_int(static_cast< int >(AST_BASIC_CONTENT_COMPOSE)));
  SWIG_Python_SetConstant(d, "AST_BASIC_CONTENT_IDENT",SWIG_From_int(static_cast< int >(AST_BASIC_CONTENT_IDENT)));
  SWIG_Python_SetConstant(d, "AST_BASIC_CONTENT_DOMAIN",SWIG_From_int(static_cast< int >(AST_BASIC_CONTENT_DOMAIN)));
  SWIG_Python_SetConstant(d, "AST_BASIC_CONTENT_CODOMAIN",SWIG_From_int(static_cast< int >(AST_BASIC_CONTENT_CODOMAIN)));
  SWIG_Python_SetConstant(d, "AST_BASIC_CONTENT_IMAGE",SWIG_From_int(static_cast< int >(AST_BASIC_CONTENT_IMAGE)));
  SWIG_Python_SetConstant(d, "AST_BASIC_CONTENT_DOMAINOFAPPLICATION",SWIG_From_int(static_cast< int >(AST_BASIC_CONTENT_DOMAINOFAPPLICATION)));
  SWIG_Python_SetConstant(d, "AST_UNKNOWN",SWIG_From_int(static_cast< int >(AST_UNKNOWN)));
  SWIG_Python_SetConstant(d, "L3P_PARSE_LOG_AS_LOG10",SWIG_From_int(static_cast< int >(L3P_PARSE_LOG_AS_LOG10)));
  SWIG_Python_SetConstant(d, "L3P_PARSE_LOG_AS_LN",SWIG_From_int(static_cast< int >(L3P_PARSE_LOG_AS_LN)));
  SWIG_Python_SetConstant(d, "L3P_PARSE_LOG_AS_ERROR",SWIG_From_int(static_cast< int >(L3P_PARSE_LOG_AS_ERROR)));
  SWIG_Python_SetConstant(d, "L3P_COLLAPSE_UNARY_MINUS",SWIG_From_bool(static_cast< bool >(true)));
  SWIG_Python_SetConstant(d, "L3P_EXPAND_UNARY_MINUS",SWIG_From_bool(static_cast< bool >(false)));
  SWIG_Python_SetConstant(d, "L3P_PARSE_UNITS",SWIG_From_bool(static_cast< bool >(true)));
  SWIG_Python_SetConstant(d, "L3P_NO_UNITS",SWIG_From_bool(static_cast< bool >(false)));
  SWIG_Python_SetConstant(d, "L3P_AVOGADRO_IS_CSYMBOL",SWIG_From_bool(static_cast< bool >(true)));
  SWIG_Python_SetConstant(d, "L3P_AVOGADRO_IS_NAME",SWIG_From_bool(static_cast< bool >(false)));
  SWIG_Python_SetConstant(d, "L3P_COMPARE_BUILTINS_CASE_INSENSITIVE",SWIG_From_bool(static_cast< bool >(false)));
  SWIG_Python_SetConstant(d, "L3P_COMPARE_BUILTINS_CASE_SENSITIVE",SWIG_From_bool(static_cast< bool >(true)));
  SWIG_Python_SetConstant(d, "L3P_MODULO_IS_REM",SWIG_From_bool(static_cast< bool >(true)));
  SWIG_Python_SetConstant(d, "L3P_MODULO_IS_PIECEWISE",SWIG_From_bool(static_cast< bool >(false)));
  SWIG_Python_SetConstant(d, "L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY",SWIG_From_bool(static_cast< bool >(true)));
  SWIG_Python_SetConstant(d, "L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC",SWIG_From_bool(static_cast< bool >(false)));
  SWIG_Python_SetConstant(d, "L3P_PARSE_PACKAGE_MATH_DIRECTLY",SWIG_From_bool(static_cast< bool >(true)));
  SWIG_Python_SetConstant(d, "L3P_PARSE_PACKAGE_MATH_AS_GENERIC",SWIG_From_bool(static_cast< bool >(false)));
  SWIG_Python_SetConstant(d, "INFIX_SYNTAX_NAMED_SQUARE_BRACKETS",SWIG_From_int(static_cast< int >(INFIX_SYNTAX_NAMED_SQUARE_BRACKETS)));
  SWIG_Python_SetConstant(d, "INFIX_SYNTAX_CURLY_BRACES",SWIG_From_int(static_cast< int >(INFIX_SYNTAX_CURLY_BRACES)));
  SWIG_Python_SetConstant(d, "INFIX_SYNTAX_CURLY_BRACES_SEMICOLON",SWIG_From_int(static_cast< int >(INFIX_SYNTAX_CURLY_BRACES_SEMICOLON)));
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

