BOSS/BossPython/BossSession_wrap.cxx

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.19
 * 
 * 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. 
 * ----------------------------------------------------------------------------- */

#define SWIGPYTHON

#ifdef __cplusplus
template<class T> class SwigValueWrapper {
    T *tt;
public:
    inline SwigValueWrapper() : tt(0) { }
    inline ~SwigValueWrapper() { if (tt) delete tt; } 
    inline SwigValueWrapper& operator=(const T& t) { tt = new T(t); return *this; }
    inline operator T&() const { return *tt; }
    inline T *operator&() { return tt; }
};                                                    
#endif


#include "Python.h"

/***********************************************************************
 * common.swg
 *
 *     This file contains generic SWIG runtime support for pointer
 *     type checking as well as a few commonly used macros to control
 *     external linkage.
 *
 * Author : David Beazley (beazley@cs.uchicago.edu)
 *
 * Copyright (c) 1999-2000, The University of Chicago
 * 
 * This file may be freely redistributed without license or fee provided
 * this copyright message remains intact.
 ************************************************************************/

#include <string.h>

#if defined(_WIN32) || defined(__WIN32__)
#       if defined(_MSC_VER)
#               if defined(STATIC_LINKED)
#                       define SWIGEXPORT(a) a
#                       define SWIGIMPORT(a) extern a
#               else
#                       define SWIGEXPORT(a) __declspec(dllexport) a
#                       define SWIGIMPORT(a) extern a
#               endif
#       else
#               if defined(__BORLANDC__)
#                       define SWIGEXPORT(a) a _export
#                       define SWIGIMPORT(a) a _export
#               else
#                       define SWIGEXPORT(a) a
#                       define SWIGIMPORT(a) a
#               endif
#       endif
#else
#       define SWIGEXPORT(a) a
#       define SWIGIMPORT(a) a
#endif

#ifdef SWIG_GLOBAL
#define SWIGRUNTIME(a) SWIGEXPORT(a)
#else
#define SWIGRUNTIME(a) static a
#endif

#ifdef __cplusplus
extern "C" {
#endif

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

typedef struct swig_type_info {
  const char             *name;                 
  swig_converter_func     converter;
  const char             *str;
  void                   *clientdata;   
  swig_dycast_func        dcast;
  struct swig_type_info  *next;
  struct swig_type_info  *prev;
} swig_type_info;

#ifdef SWIG_NOINCLUDE

SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
SWIGIMPORT(const char *)     SWIG_TypeName(const swig_type_info *);
SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);

#else

static swig_type_info *swig_type_list = 0;

/* Register a type mapping with the type-checking */
SWIGRUNTIME(swig_type_info *)
SWIG_TypeRegister(swig_type_info *ti)
{
  swig_type_info *tc, *head, *ret, *next;
  /* Check to see if this type has already been registered */
  tc = swig_type_list;
  while (tc) {
    if (strcmp(tc->name, ti->name) == 0) {
      /* Already exists in the table.  Just add additional types to the list */
      if (tc->clientdata) ti->clientdata = tc->clientdata;      
      head = tc;
      next = tc->next;
      goto l1;
    }
    tc = tc->prev;
  }
  head = ti;
  next = 0;

  /* Place in list */
  ti->prev = swig_type_list;
  swig_type_list = ti;

  /* Build linked lists */
 l1:
  ret = head;
  tc = ti + 1;
  /* Patch up the rest of the links */
  while (tc->name) {
    head->next = tc;
    tc->prev = head;
    head = tc;
    tc++;
  }
  if (next) next->prev = head;  /**/
  head->next = next;
  return ret;
}

/* Check the typename */
SWIGRUNTIME(swig_type_info *) 
SWIG_TypeCheck(char *c, swig_type_info *ty)
{
  swig_type_info *s;
  if (!ty) return 0;        /* Void pointer */
  s = ty->next;             /* First element always just a name */
  do {
    if (strcmp(s->name,c) == 0) {
      if (s == ty->next) return s;
      /* Move s to the top of the linked list */
      s->prev->next = s->next;
      if (s->next) {
        s->next->prev = s->prev;
      }
      /* Insert s as second element in the list */
      s->next = ty->next;
      if (ty->next) ty->next->prev = s;
      ty->next = s;
      s->prev = ty;  /**/
      return s;
    }
    s = s->next;
  } while (s && (s != ty->next));
  return 0;
}

/* Cast a pointer up an inheritance hierarchy */
SWIGRUNTIME(void *) 
SWIG_TypeCast(swig_type_info *ty, void *ptr) 
{
  if ((!ty) || (!ty->converter)) return ptr;
  return (*ty->converter)(ptr);
}

/* 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 */
SWIGRUNTIME(const char *)
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/* Search for a swig_type_info structure */
SWIGRUNTIME(swig_type_info *)
SWIG_TypeQuery(const char *name) {
  swig_type_info *ty = swig_type_list;
  while (ty) {
    if (ty->str && (strcmp(name,ty->str) == 0)) return ty;
    if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
    ty = ty->prev;
  }
  return 0;
}

/* Set the clientdata field for a type */
SWIGRUNTIME(void)
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_type_info *tc, *equiv;
  if (ti->clientdata == clientdata) return;
  ti->clientdata = clientdata;
  equiv = ti->next;
  while (equiv) {
    if (!equiv->converter) {
      tc = swig_type_list;
      while (tc) {
        if ((strcmp(tc->name, equiv->name) == 0))
          SWIG_TypeClientData(tc,clientdata);
        tc = tc->prev;
      }
    }
    equiv = equiv->next;
  }
}
#endif

#ifdef __cplusplus
}

#endif

/***********************************************************************
 * python.swg
 *
 *     This file contains the runtime support for Python modules
 *     and includes code for managing global variables and pointer
 *     type checking.
 *
 * Author : David Beazley (beazley@cs.uchicago.edu)
 ************************************************************************/

#include "Python.h"

#ifdef __cplusplus
extern "C" {
#endif

#define SWIG_PY_INT     1
#define SWIG_PY_FLOAT   2
#define SWIG_PY_STRING  3
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Flags for pointer conversion */

#define SWIG_POINTER_EXCEPTION     0x1
#define SWIG_POINTER_DISOWN        0x2

/* Exception handling in wrappers */
#define SWIG_fail   goto fail

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

#ifdef SWIG_NOINCLUDE

SWIGEXPORT(PyObject *)        SWIG_newvarlink(void);
SWIGEXPORT(void)              SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
SWIGEXPORT(int)               SWIG_ConvertPtr(PyObject *, void **, swig_type_info *, int);
SWIGEXPORT(int)               SWIG_ConvertPacked(PyObject *, void *, int sz, swig_type_info *, int);
SWIGEXPORT(char *)            SWIG_PackData(char *c, void *, int);
SWIGEXPORT(char *)            SWIG_UnpackData(char *c, void *, int);
SWIGEXPORT(PyObject *)        SWIG_NewPointerObj(void *, swig_type_info *,int own);
SWIGEXPORT(PyObject *)        SWIG_NewPackedObj(void *, int sz, swig_type_info *);
SWIGEXPORT(void)              SWIG_InstallConstants(PyObject *d, swig_const_info constants[]);
#else

/* -----------------------------------------------------------------------------
 * 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;

static PyObject *
swig_varlink_repr(swig_varlinkobject *v) {
  v = v;
  return PyString_FromString("<Global variables>");
}

static int
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
  swig_globalvar  *var;
  flags = flags;
  fprintf(fp,"Global variables { ");
  for (var = v->vars; var; var=var->next) {
    fprintf(fp,"%s", var->name);
    if (var->next) fprintf(fp,", ");
  }
  fprintf(fp," }\n");
  return 0;
}

static PyObject *
swig_varlink_getattr(swig_varlinkobject *v, char *n) {
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      return (*var->get_attr)();
    }
    var = var->next;
  }
  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
  return NULL;
}

static int
swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      return (*var->set_attr)(p);
    }
    var = var->next;
  }
  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
  return 1;
}

statichere PyTypeObject varlinktype = {
  PyObject_HEAD_INIT(0)              
  0,
  (char *)"swigvarlink",                      /* Type name    */
  sizeof(swig_varlinkobject),         /* Basic size   */
  0,                                  /* Itemsize     */
  0,                                  /* Deallocator  */ 
  (printfunc) swig_varlink_print,     /* Print        */
  (getattrfunc) swig_varlink_getattr, /* get attr     */
  (setattrfunc) swig_varlink_setattr, /* Set attr     */
  0,                                  /* tp_compare   */
  (reprfunc) swig_varlink_repr,       /* tp_repr      */    
  0,                                  /* tp_as_number */
  0,                                  /* tp_as_mapping*/
  0,                                  /* tp_hash      */
};

/* Create a variable linking object for use later */
SWIGRUNTIME(PyObject *)
SWIG_newvarlink(void) {
  swig_varlinkobject *result = 0;
  result = PyMem_NEW(swig_varlinkobject,1);
  varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
  result->ob_type = &varlinktype;
  result->vars = 0;
  result->ob_refcnt = 0;
  Py_XINCREF((PyObject *) result);
  return ((PyObject*) result);
}

SWIGRUNTIME(void)
SWIG_addvarlink(PyObject *p, char *name,
           PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
  swig_varlinkobject *v;
  swig_globalvar *gv;
  v= (swig_varlinkobject *) p;
  gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
  gv->name = (char *) malloc(strlen(name)+1);
  strcpy(gv->name,name);
  gv->get_attr = get_attr;
  gv->set_attr = set_attr;
  gv->next = v->vars;
  v->vars = gv;
}

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

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

/* Convert a pointer value */
SWIGRUNTIME(int)
SWIG_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  char  *c;
  static PyObject *SWIG_this = 0;
  int    newref = 0;
  PyObject  *pyobj = 0;

  if (!obj) return 0;
  if (obj == Py_None) {
    *ptr = 0;
    return 0;
  }
#ifdef SWIG_COBJECT_TYPES
  if (!(PyCObject_Check(obj))) {
    if (!SWIG_this)
      SWIG_this = PyString_FromString("this");
    pyobj = obj;
    obj = PyObject_GetAttr(obj,SWIG_this);
    newref = 1;
    if (!obj) goto type_error;
    if (!PyCObject_Check(obj)) {
      Py_DECREF(obj);
      goto type_error;
    }
  }  
  *ptr = PyCObject_AsVoidPtr(obj);
  c = (char *) PyCObject_GetDesc(obj);
  if (newref) Py_DECREF(obj);
  goto cobject;
#else
  if (!(PyString_Check(obj))) {
    if (!SWIG_this)
      SWIG_this = PyString_FromString("this");
    pyobj = obj;
    obj = PyObject_GetAttr(obj,SWIG_this);
    newref = 1;
    if (!obj) goto type_error;
    if (!PyString_Check(obj)) {
      Py_DECREF(obj);
      goto type_error;
    }
  } 
  c = PyString_AsString(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') {
    *ptr = (void *) 0;
    if (strcmp(c,"NULL") == 0) {
      if (newref) { Py_DECREF(obj); }
      return 0;
    } else {
      if (newref) { Py_DECREF(obj); }
      goto type_error;
    }
  }
  c++;
  c = SWIG_UnpackData(c,ptr,sizeof(void *));
  if (newref) { Py_DECREF(obj); }
#endif

#ifdef SWIG_COBJECT_TYPES
cobject:
#endif

  if (ty) {
    tc = SWIG_TypeCheck(c,ty);
    if (!tc) goto type_error;
    *ptr = SWIG_TypeCast(tc,(void*) *ptr);
  }

  if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
      PyObject *zero = PyInt_FromLong(0);
      PyObject_SetAttrString(pyobj,(char*)"thisown",zero);
      Py_DECREF(zero);
  }
  return 0;

type_error:
  if (flags & SWIG_POINTER_EXCEPTION) {
    if (ty) {
      char *temp = (char *) malloc(64+strlen(ty->name));
      sprintf(temp,"Type error. Expected %s", ty->name);
      PyErr_SetString(PyExc_TypeError, temp);
      free((char *) temp);
    } else {
      PyErr_SetString(PyExc_TypeError,"Expected a pointer");
    }
  }
  return -1;
}

/* Convert a packed value value */
SWIGRUNTIME(int)
SWIG_ConvertPacked(PyObject *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  char  *c;

  if ((!obj) || (!PyString_Check(obj))) goto type_error;
  c = PyString_AsString(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') goto type_error;
  c++;
  c = SWIG_UnpackData(c,ptr,sz);
  if (ty) {
    tc = SWIG_TypeCheck(c,ty);
    if (!tc) goto type_error;
  }
  return 0;

type_error:

  if (flags) {
    if (ty) {
      char *temp = (char *) malloc(64+strlen(ty->name));
      sprintf(temp,"Type error. Expected %s", ty->name);
      PyErr_SetString(PyExc_TypeError, temp);
      free((char *) temp);
    } else {
      PyErr_SetString(PyExc_TypeError,"Expected a pointer");
    }
  }
  return -1;
}

/* Create a new pointer object */
SWIGRUNTIME(PyObject *)
SWIG_NewPointerObj(void *ptr, swig_type_info *type, int own) {
  PyObject *robj;
  if (!ptr) {
    Py_INCREF(Py_None);
    return Py_None;
  }
#ifdef SWIG_COBJECT_TYPES
  robj = PyCObject_FromVoidPtrAndDesc((void *) ptr, (char *) type->name, NULL);
#else
  {
    char result[1024];
    char *r = result;
    *(r++) = '_';
    r = SWIG_PackData(r,&ptr,sizeof(void *));
    strcpy(r,type->name);
    robj = PyString_FromString(result);
  }
#endif
  if (!robj || (robj == Py_None)) return robj;
  if (type->clientdata) {
    PyObject *inst;
    PyObject *args = Py_BuildValue((char*)"(O)", robj);
    Py_DECREF(robj);
    inst = PyObject_CallObject((PyObject *) type->clientdata, args);
    Py_DECREF(args);
    if (inst) {
      if (own) {
        PyObject *n = PyInt_FromLong(1);
        PyObject_SetAttrString(inst,(char*)"thisown",n);
        Py_DECREF(n);
      }
      robj = inst;
    }
  }
  return robj;
}

SWIGRUNTIME(PyObject *)
SWIG_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
  char result[1024];
  char *r = result;
  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  strcpy(r,type->name);
  return PyString_FromString(result);
}

/* Install Constants */
SWIGRUNTIME(void)
SWIG_InstallConstants(PyObject *d, swig_const_info constants[]) {
  int i;
  PyObject *obj;
  for (i = 0; constants[i].type; i++) {
    switch(constants[i].type) {
    case SWIG_PY_INT:
      obj = PyInt_FromLong(constants[i].lvalue);
      break;
    case SWIG_PY_FLOAT:
      obj = PyFloat_FromDouble(constants[i].dvalue);
      break;
    case SWIG_PY_STRING:
      obj = PyString_FromString((char *) constants[i].pvalue);
      break;
    case SWIG_PY_POINTER:
      obj = SWIG_NewPointerObj(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);
    }
  }
}

#endif

#ifdef __cplusplus
}
#endif


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

#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[0] 
#define  SWIGTYPE_p_XMLDoc swig_types[1] 
#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2] 
#define  SWIGTYPE_p_BossProgramExec swig_types[3] 
#define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[4] 
#define  SWIGTYPE_p_BossChain swig_types[5] 
#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[6] 
#define  SWIGTYPE_p_BossTask swig_types[7] 
#define  SWIGTYPE_p_BossTaskException swig_types[8] 
#define  SWIGTYPE_p_std__ostream swig_types[9] 
#define  SWIGTYPE_p_BossProgram swig_types[10] 
#define  SWIGTYPE_p_printOption swig_types[11] 
#define  SWIGTYPE_p_BossAttributeContainer swig_types[12] 
#define  SWIGTYPE_p_BossJob swig_types[13] 
#define  SWIGTYPE_p_BossDatabase swig_types[14] 
#define  SWIGTYPE_p_BossSession swig_types[15] 
#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[16] 
#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[17] 
#define  SWIGTYPE_p_BossAdministratorSession swig_types[18] 
#define  SWIGTYPE_p_BossTask__job_iterator swig_types[19] 
#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[20] 
#define  SWIGTYPE_p_jobStates swig_types[21] 
static swig_type_info *swig_types[23];

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


/*-----------------------------------------------
              @(target):= _BossSession.so
  ------------------------------------------------*/
#define SWIG_init    init_BossSession

#define SWIG_name    "_BossSession"

#define  SWIG_MemoryError    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_UnknownError  99


static void _SWIG_exception(int code, const char *msg) {
  switch(code) {
  case SWIG_MemoryError:
    PyErr_SetString(PyExc_MemoryError,msg);
    break;
  case SWIG_IOError:
    PyErr_SetString(PyExc_IOError,msg);
    break;
  case SWIG_RuntimeError:
    PyErr_SetString(PyExc_RuntimeError,msg);
    break;
  case SWIG_IndexError:
    PyErr_SetString(PyExc_IndexError,msg);
    break;
  case SWIG_TypeError:
    PyErr_SetString(PyExc_TypeError,msg);
    break;
  case SWIG_DivisionByZero:
    PyErr_SetString(PyExc_ZeroDivisionError,msg);
    break;
  case SWIG_OverflowError:
    PyErr_SetString(PyExc_OverflowError,msg);
    break;
  case SWIG_SyntaxError:
    PyErr_SetString(PyExc_SyntaxError,msg);
    break;
  case SWIG_ValueError:
    PyErr_SetString(PyExc_ValueError,msg);
    break;
  case SWIG_SystemError:
    PyErr_SetString(PyExc_SystemError,msg);
    break;
  default:
    PyErr_SetString(PyExc_RuntimeError,msg);
    break;
  }
}

#define SWIG_exception(a,b) { _SWIG_exception(a,b); SWIG_fail; }


#include <string>


#include <string>

PyObject* SwigInt_FromBool(bool b) {
    return PyInt_FromLong(b ? 1L : 0L);
}
double SwigNumber_Check(PyObject* o) {
    return PyFloat_Check(o) || PyInt_Check(o) || PyLong_Check(o);
}
double SwigNumber_AsDouble(PyObject* o) {
    return PyFloat_Check(o) ? PyFloat_AsDouble(o) 
        : (PyInt_Check(o) ?   double(PyInt_AsLong(o))
                            : double(PyLong_AsLong(o)));
}
PyObject* SwigString_FromString(const std::string& s) {
    return PyString_FromStringAndSize(s.data(),s.size());
}
std::string SwigString_AsString(PyObject* o) {
    return std::string(PyString_AsString(o));
}


#include <vector>
#include <algorithm>
#include <stdexcept>


#include <map>
#include <algorithm>
#include <stdexcept>

bool std_maplstd_stringcstd_string_g___nonzero_____(std::map<std::string,std::string > *self){
                return !(self->empty());
            }
std::string std_maplstd_stringcstd_string_g___getitem_____(std::map<std::string,std::string > *self,std::string key){
                std::map<std::string,std::string >::iterator i = self->find(key);
                if (i != self->end())
                    return i->second;
                else
                    throw std::out_of_range("key not found");
            }
void std_maplstd_stringcstd_string_g___setitem_____(std::map<std::string,std::string > *self,std::string key,std::string x){
                (*self)[key] = x;
            }
void std_maplstd_stringcstd_string_g___delitem_____(std::map<std::string,std::string > *self,std::string key){
                std::map<std::string,std::string >::iterator i = self->find(key);
                if (i != self->end())
                    self->erase(i);
                else
                    throw std::out_of_range("key not found");
            }
bool std_maplstd_stringcstd_string_g_has_key___(std::map<std::string,std::string > *self,std::string key){
                std::map<std::string,std::string >::iterator i = self->find(key);
                return i != self->end();
            }
PyObject *std_maplstd_stringcstd_string_g_keys___(std::map<std::string,std::string > *self){
                PyObject* keyList = PyList_New(self->size());
                std::map<std::string,std::string >::iterator i;
                unsigned int j;
                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
                    PyList_SetItem(keyList,j,
                                   SwigString_FromString(i->first));
                }
                return keyList;
            }
PyObject *std_maplstd_stringcstd_string_g_values___(std::map<std::string,std::string > *self){
                PyObject* valueList = PyList_New(self->size());
                std::map<std::string,std::string >::iterator i;
                unsigned int j;
                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
                    PyList_SetItem(valueList,j,
                                   SwigString_FromString(i->second));
                }
                return valueList;
            }
PyObject *std_maplstd_stringcstd_string_g_items___(std::map<std::string,std::string > *self){
                PyObject* itemList = PyList_New(self->size());
                std::map<std::string,std::string >::iterator i;
                unsigned int j;
                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
                    PyObject* item = PyTuple_New(2);
                    PyTuple_SetItem(item,0,
                                    SwigString_FromString(i->first));
                    PyTuple_SetItem(item,1,
                                    SwigString_FromString(i->second));
                    PyList_SetItem(itemList,j,item);
                }
                return itemList;
            }
bool std_maplstd_stringcstd_string_g___contains_____(std::map<std::string,std::string > *self,std::string key){
                std::map<std::string,std::string >::iterator i = self->find(key);
                return i != self->end();
            }
PyObject *std_maplstd_stringcstd_string_g___iter_____(std::map<std::string,std::string > *self){
                #if PY_VERSION_HEX >= 0x02020000
                PyObject* keyList = PyList_New(self->size());
                std::map<std::string,std::string >::iterator i;
                unsigned int j;
                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
                    PyList_SetItem(keyList,j,
                                   SwigString_FromString(i->first));
                }
                PyObject* iter = PyObject_GetIter(keyList);
                Py_DECREF(keyList);
                return iter;
                #else
                throw std::runtime_error("Python 2.2 or later is needed"
                                         " for iterator support");
                #endif
            }
std::string std_vectorlstd_string_g_pop___(std::vector<std::string > *self){
                if (self->size() == 0)
                    throw std::out_of_range("pop from empty vector");
                std::string x = self->back();
                self->pop_back();
                return x;
            }
std::string std_vectorlstd_string_g___getitem_____(std::vector<std::string > *self,int i){
                int size = int(self->size());
                if (i<0) i += size;
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
std::vector<std::string > std_vectorlstd_string_g___getslice_____(std::vector<std::string > *self,int i,int j){
                int size = int(self->size());
                if (i<0) i = size+i;
                if (j<0) j = size+j;
                if (i<0) i = 0;
                if (j>size) j = size;
                std::vector<std::string > tmp(j-i);
                std::copy(self->begin()+i,self->begin()+j,tmp.begin());
                return tmp;
            }
void std_vectorlstd_string_g___setitem_____(std::vector<std::string > *self,int i,std::string x){
                int size = int(self->size());
                if (i<0) i+= size;
                if (i>=0 && i<size)
                    (*self)[i] = x;
                else
                    throw std::out_of_range("vector index out of range");
            }
void std_vectorlstd_string_g___setslice_____(std::vector<std::string > *self,int i,int j,std::vector<std::string > const &v){
                int size = int(self->size());
                if (i<0) i = size+i;
                if (j<0) j = size+j;
                if (i<0) i = 0;
                if (j>size) j = size;
                if (int(v.size()) == j-i) {
                    std::copy(v.begin(),v.end(),self->begin()+i);
                } else {
                    self->erase(self->begin()+i,self->begin()+j);
                    if (i+1 <= int(self->size()))
                        self->insert(self->begin()+i,v.begin(),v.end());
                    else
                        self->insert(self->end(),v.begin(),v.end());
                }
            }
void std_vectorlstd_string_g___delitem_____(std::vector<std::string > *self,int i){
                int size = int(self->size());
                if (i<0) i+= size;
                if (i>=0 && i<size)
                    self->erase(self->begin()+i);
                else
                    throw std::out_of_range("vector index out of range");
            }
void std_vectorlstd_string_g___delslice_____(std::vector<std::string > *self,int i,int j){
                int size = int(self->size());
                if (i<0) i = size+i;
                if (j<0) j = size+j;
                if (i<0) i = 0;
                if (j>size) j = size;
                self->erase(self->begin()+i,self->begin()+j);
            }

static PyObject * BossError;
static PyObject * SchedulerError;
#include "BossSession.h"
#include "BossAdministratorSession.h"
#include "BossTask.h"
#include "BossJob.h"
#include "BossChain.h"
#include "BossTaskCore.h"
#include "BossAttributeContainer.h"
#include "BossDBObject.h"
#include "BossProgram.h"
#include "BossProgramExec.h"
#include "BossDatabase.h"
#include "BossScheduler.h"
#include "BossDeclaration.h"

PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
    PyObject *  my_list = PyList_New( my_vec.size());
    unsigned int index = 0;
    for ( std::vector<std::string>::const_iterator it = my_vec.begin ();
          it != my_vec.end(); ++it, ++index) {
      PyList_SetItem( my_list, index, PyString_FromString( it->c_str() ));
    }
    return my_list;
  }
PyObject *BossSession_CHTools(BossSession *self){
    std::vector<std::string> my_vec = self->showCHTools();
    return BossSession_show( self, my_vec );
  }
PyObject *BossSession_ProgramTypes(BossSession *self){
    std::vector<std::string> my_vec = self->showProgramTypes();
    return BossSession_show( self, my_vec );
  }
PyObject *BossSession_RTMons(BossSession *self){
    std::vector<std::string> my_vec = self->showRTMon();
    return BossSession_show( self, my_vec );
  }
PyObject *BossSession_schedulers(BossSession *self){
    std::vector<std::string> my_vec = self->showSchedulers();
    return BossSession_show( self, my_vec );
  }
PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,unsigned int timeout){
    std::vector<std::string> my_vec = self->listMatch( scheduler,
                                                       schclassad,
                                                       taskid,
                                                       jobid,
                                                       timeout);
    return BossSession_show( self, my_vec );
  }
PyObject *BossSession_queryTasks(BossSession *self,std::string const &taskName,std::string const &taskRange,std::string after,std::string before,std::string user){
      PyObject * task_list = PyList_New(0);
      std::vector <std::string> taskList;
      if ( taskName.empty() ) {
        taskList = self->selectTasks( taskRange, before, after, user);
      } else {
        taskList = self->selectTasksByName( taskName );
      }
      for ( std::vector <std::string>::const_iterator it= taskList.begin();
            it!= taskList.end(); ++it ) {
        PyList_Append( task_list,  PyString_FromString(it->c_str() ) );
      }
      return  task_list;
    }
void BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
    std::string tmp;
    BossAttributeContainer::const_iterator it_end = obj.end ();
    for (BossAttributeContainer::const_iterator it = obj.begin ();
         it != it_end; ++it) {

      PyObject * key = PyString_FromString( (it->first.name()).c_str() );
      PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
      PyDict_SetItem( dict, key, val);
      Py_DECREF(key);
      Py_DECREF(val);
    }
    return;
  }
void BossTask_jobDict(BossTask const *self,BossJob const *jobH,PyObject *job_dict){

    //    PyObject * job_dict = PyDict_New();
    std::string tmp;

    BossAttributeContainer obj = jobH->getTableEntries("JOB");
    BossTask_appendToPyDict ( self, job_dict, obj );

    std::set<std::string> sch = jobH->getSchedulerElements();
    std::set<std::string>::const_iterator sch_end =  sch.end();
    for (std::set<std::string>::const_iterator it =sch.begin();
         it != sch_end; ++ it ) {

      tmp = (*jobH)["JOB_SCHED_INFO."+(*it)];
      PyObject * key = PyString_FromString( it->c_str() );
      PyObject * val = PyString_FromString( tmp.c_str() );
      PyDict_SetItem( job_dict, key, val);
      Py_DECREF(key);
      Py_DECREF(val);
    }
    return;
  }
PyObject *BossTask_jobsDict(BossTask *self){
  
    PyObject * job_dict = PyDict_New();
    if ( self->job_begin () == self->job_end ()) self->load(ALL);
    for (BossTask::job_iterator jit = self->job_begin ();
         jit != self->job_end (); ++jit) {
      PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
      PyObject * tmp_dict = PyDict_New();
      BossTask_jobDict( self, *jit, tmp_dict );
      PyDict_SetItem( job_dict, id, tmp_dict );
      Py_DECREF(id);
      Py_DECREF(tmp_dict);
    }
    return job_dict;
  }
PyObject *BossTask_job(BossTask *self,std::string const &jobid){
  
    PyObject * job_dict = PyDict_New();
    self->load( ALL, jobid );
    BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
    return job_dict;
  }
PyObject *BossTask_Chain(BossTask *self,std::string const &jobid){
  
    PyObject * chain_dict = PyDict_New();
    BossAttributeContainer obj =
      self->chain( jobid ).getTableEntries("CHAIN");
    BossTask_appendToPyDict ( self, chain_dict, obj );
    return chain_dict;
  }
PyObject *BossTask_jobStates(BossTask *self){
  
    PyObject * job_dict = PyDict_New();
    if ( self->job_begin () == self->job_end ()) self->load(ALL);
    for (BossTask::job_iterator jit = self->job_begin ();
         jit != self->job_end (); ++jit) {
      PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
      PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
      PyDict_SetItem( job_dict, id, status );
      Py_DECREF(id);
      Py_DECREF(status);
    }
    return job_dict;
  }
PyObject *BossTask_jobStatistic(BossTask *self){
  
    PyObject * job_dict = PyDict_New();
    if ( self->job_begin () == self->job_end ()) self->load(ALL);
    std::map< std::string, int > states;
    for (BossTask::job_iterator jit = self->job_begin ();
         jit != self->job_end (); ++jit) {
      ++states[(**jit)["JOB.STATUS"]];
    }

    std::map< std::string, int >::const_iterator end = states.end ();
    for (std::map< std::string, int >::const_iterator it = states.begin ();
         it != end; ++it) {
      PyObject * status = PyString_FromString( (it->first).c_str() );
      PyObject * jobs = PyString_FromFormat( "%d", it->second );
      PyDict_SetItem( job_dict, status, jobs );
      Py_DECREF(jobs);
      Py_DECREF(status);
    }
    return job_dict;
  }
PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator &programs_it){

    PyObject * job_dict = PyDict_New();

    std::string tmp;

    // PROGRAM
    BossAttributeContainer obj =
      (programs_it->first).getTableEntries("PROGRAM");
    BossTask_appendToPyDict ( self, job_dict, obj );

    // PROGRAM_EXEC
    obj.clear();
    obj = (programs_it->second).getTableEntries("PROGRAM_EXEC");
    BossTask_appendToPyDict ( self, job_dict, obj );

    // SPECIFICS
    std::vector < BossAttributeContainer >::const_iterator it;
    std::vector < BossAttributeContainer >::const_iterator it_end = (programs_it->second).specEnd ();
    for ( it = (programs_it->second).specBegin (); it != it_end; ++it) {
      BossTask_appendToPyDict ( self, job_dict, *it );
    }
    return job_dict;
  }
PyObject *BossTask_jobPrograms(BossTask const *self,std::string const &jobid){

    const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
    std::map< std::string, std::map< std::string, std::string > > ret_val;
    std::vector< std::pair<BossProgram, BossProgramExec > >
      programs = self->queryJobPrograms ( jH );
    std::vector< std::pair<BossProgram, BossProgramExec > >::const_iterator
      programs_it_end = programs.end();
    std::vector< std::pair<BossProgram, BossProgramExec > >::const_iterator
      programs_it;


    PyObject * job_dict = PyDict_New();

    for ( programs_it = programs.begin(); programs_it != programs_it_end;
          ++programs_it  ) {
      std::string id = (programs_it->first)["PROGRAM.ID"];
      PyObject * tmp_dict =  BossTask_progDict( self, programs_it );
      PyObject * myid =  PyString_FromString(id.c_str() );
      PyDict_SetItem( job_dict, myid, tmp_dict );
      Py_DECREF(myid);
      Py_DECREF(tmp_dict);
    }
    return job_dict;
  }
PyObject *BossTask_program(BossTask *self,std::string const &jobid,std::string const &programId){
  
    PyObject * job_dict = PyDict_New();

    const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
    BossAttributeContainer obj =
      self->queryProgram( jH, programId ).getTableEntries("PROGRAM");
    BossTask_appendToPyDict ( self, job_dict, obj );
    return job_dict;
  }
PyObject *BossTask_programExec(BossTask *self,std::string const &jobid,std::string const &programId){
  
    PyObject * job_dict = PyDict_New();

    const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);

    // PROGRAM_EXEC
    BossProgramExec programExec = self->queryProgramExec( jH, programId );
    BossAttributeContainer obj = programExec.getTableEntries("PROGRAM_EXEC");
    BossTask_appendToPyDict ( self, job_dict, obj );

    // SPECIFICS
    std::vector < BossAttributeContainer >::const_iterator it;
    std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
    for ( it = programExec.specBegin (); it != it_end; ++it) {
      BossTask_appendToPyDict ( self, job_dict, *it );
    }
    return job_dict;
  }
PyObject *BossTask_specific(BossTask *self,std::string const &jobid,std::string const &programId){
  
    PyObject * job_dict = PyDict_New();

    const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
    BossProgramExec programExec = self->queryProgramExec( jH, programId );
    BossAttributeContainer obj = programExec.getKeys ();
    BossTask_appendToPyDict ( self, job_dict, obj );
    
    std::vector < BossAttributeContainer >::const_iterator it;
    std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
    for ( it = programExec.specBegin (); it != it_end; ++it) {
      BossTask_appendToPyDict ( self, job_dict, *it );
    }
    return job_dict;
  }
#ifdef __cplusplus
extern "C" {
#endif
static PyObject *_wrap_new_objectMap__SWIG_0(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *result;
    
    if(!PyArg_ParseTuple(args,(char *)":new_objectMap")) goto fail;
    {
        try {
            result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_new_objectMap__SWIG_1(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = 0 ;
    std::map<std::string,std::string > *result;
    std::map<std::string,std::string > temp1 ;
    std::map<std::string,std::string > *m1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:new_objectMap",&obj0)) goto fail;
    {
        if (PyDict_Check(obj0)) {
            PyObject* items = PyMapping_Items(obj0);
            unsigned int size = PyList_Size(items);
            temp1 = std::map<std::string,std::string >();
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                PyObject* pair = PySequence_GetItem(items,i);
                PyObject* key = PySequence_GetItem(pair,0);
                PyObject* o = PySequence_GetItem(pair,1);
                if (PyString_Check(key) && PyString_Check(o)) {
                    temp1[SwigString_AsString(key)] = SwigString_AsString(o);
                    Py_DECREF(key);
                    Py_DECREF(o);
                    Py_DECREF(pair);
                }else {
                    Py_DECREF(key);
                    Py_DECREF(o);
                    Py_DECREF(pair);
                    Py_DECREF(items);
                    PyErr_SetString(PyExc_TypeError,
                    "map<""std::string"",""std::string""> expected");
                    SWIG_fail;
                }
            }
            Py_DECREF(items);
        }else if (SWIG_ConvertPtr(obj0,(void **) &m1,
        SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1) {
            arg1 = m1;
        }else {
            PyErr_SetString(PyExc_TypeError,
            "map<""std::string"",""std::string""> expected");
            SWIG_fail;
        }
    }
    {
        try {
            result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_new_objectMap(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[2];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 0) {
        return _wrap_new_objectMap__SWIG_0(self,args);
    }
    if (argc == 1) {
        int _v;
        {
            /* native sequence? */
            if (PyDict_Check(argv[0])) {
                PyObject* items = PyMapping_Items(argv[0]);
                unsigned int size = PyList_Size(items);
                if (size == 0) {
                    /* an empty dictionary can be of any type */
                    _v = 1;
                }else {
                    /* check the first element only */
                    PyObject* pair = PySequence_GetItem(items,0);
                    PyObject* key = PySequence_GetItem(pair,0);
                    PyObject* o = PySequence_GetItem(pair,1);
                    if (PyString_Check(key) && PyString_Check(o))
                    _v = 1;
                    else
                    _v = 0;
                    Py_DECREF(key);
                    Py_DECREF(o);
                    Py_DECREF(pair);
                }
                Py_DECREF(items);
            }else {
                /* wrapped map? */
                std::map<std::string,std::string >* m;
                if (SWIG_ConvertPtr(argv[0],(void **) &m,
                SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1)
                _v = 1;
                else
                _v = 0;
            }
        }
        if (_v) {
            return _wrap_new_objectMap__SWIG_1(self,args);
        }
    }
    
    PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_objectMap'");
    return NULL;
}


static PyObject *_wrap_objectMap___len__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    unsigned int result;
    std::map<std::string,std::string > temp1 ;
    std::map<std::string,std::string > *m1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:objectMap___len__",&obj0)) goto fail;
    {
        if (PyDict_Check(obj0)) {
            PyObject* items = PyMapping_Items(obj0);
            unsigned int size = PyList_Size(items);
            temp1 = std::map<std::string,std::string >();
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                PyObject* pair = PySequence_GetItem(items,i);
                PyObject* key = PySequence_GetItem(pair,0);
                PyObject* o = PySequence_GetItem(pair,1);
                if (PyString_Check(key) && PyString_Check(o)) {
                    temp1[SwigString_AsString(key)] = SwigString_AsString(o);
                    Py_DECREF(key);
                    Py_DECREF(o);
                    Py_DECREF(pair);
                }else {
                    Py_DECREF(key);
                    Py_DECREF(o);
                    Py_DECREF(pair);
                    Py_DECREF(items);
                    PyErr_SetString(PyExc_TypeError,
                    "map<""std::string"",""std::string""> expected");
                    SWIG_fail;
                }
            }
            Py_DECREF(items);
        }else if (SWIG_ConvertPtr(obj0,(void **) &m1,
        SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1) {
            arg1 = m1;
        }else {
            PyErr_SetString(PyExc_TypeError,
            "map<""std::string"",""std::string""> expected");
            SWIG_fail;
        }
    }
    {
        try {
            result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_objectMap_clear(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:objectMap_clear",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            (arg1)->clear();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_objectMap___nonzero__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:objectMap___nonzero__",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_objectMap___getitem__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    std::string arg2 ;
    std::string result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___getitem__",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1))
        arg2 = std::string(PyString_AsString(obj1));
        else
        SWIG_exception(SWIG_TypeError, "string expected");
    }
    {
        try {
            result = std_maplstd_stringcstd_string_g___getitem_____(arg1,arg2);
            
        }catch (std::out_of_range& e) {
            PyErr_SetString(PyExc_KeyError,const_cast<char*>(e.what()));
            SWIG_fail;
        }
    }
    {
        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_objectMap___setitem__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    std::string arg2 ;
    std::string arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:objectMap___setitem__",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1))
        arg2 = std::string(PyString_AsString(obj1));
        else
        SWIG_exception(SWIG_TypeError, "string expected");
    }
    {
        if (PyString_Check(obj2))
        arg3 = std::string(PyString_AsString(obj2));
        else
        SWIG_exception(SWIG_TypeError, "string expected");
    }
    {
        try {
            std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_objectMap___delitem__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    std::string arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___delitem__",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1))
        arg2 = std::string(PyString_AsString(obj1));
        else
        SWIG_exception(SWIG_TypeError, "string expected");
    }
    {
        try {
            std_maplstd_stringcstd_string_g___delitem_____(arg1,arg2);
            
        }catch (std::out_of_range& e) {
            PyErr_SetString(PyExc_KeyError,const_cast<char*>(e.what()));
            SWIG_fail;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_objectMap_has_key(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    std::string arg2 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:objectMap_has_key",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1))
        arg2 = std::string(PyString_AsString(obj1));
        else
        SWIG_exception(SWIG_TypeError, "string expected");
    }
    {
        try {
            result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_objectMap_keys(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:objectMap_keys",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_objectMap_values(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:objectMap_values",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_objectMap_items(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:objectMap_items",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_objectMap___contains__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    std::string arg2 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___contains__",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1))
        arg2 = std::string(PyString_AsString(obj1));
        else
        SWIG_exception(SWIG_TypeError, "string expected");
    }
    {
        try {
            result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_objectMap___iter__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:objectMap___iter__",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (PyObject *)std_maplstd_stringcstd_string_g___iter_____(arg1);
            
        }catch (std::runtime_error& e) {
            PyErr_SetString(PyExc_RuntimeError,const_cast<char*>(e.what()));
            SWIG_fail;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_objectMap(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_objectMap",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            delete arg1;
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * objectMap_swigregister(PyObject *self, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_std__mapTstd__string_std__string_t, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    unsigned int arg1 = (unsigned int) 0 ;
    std::vector<std::string > *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
    if (obj0) {
        arg1 = (unsigned int) PyInt_AsLong(obj0);
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    unsigned int arg1 ;
    std::string *arg2 = 0 ;
    std::vector<std::string > *result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
    arg1 = (unsigned int) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = 0 ;
    std::vector<std::string > *result;
    std::vector<std::string > temp1 ;
    std::vector<std::string > *v1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
    {
        if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
            unsigned int size = (PyTuple_Check(obj0) ?
            PyTuple_Size(obj0) :
            PyList_Size(obj0));
            temp1 = std::vector<std::string >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                PyObject* o = PySequence_GetItem(obj0,i);
                if (PyString_Check(o)) {
                    temp1[i] = (std::string)(\
                    SwigString_AsString(o));
                    Py_DECREF(o);
                }else {
                    Py_DECREF(o);
                    PyErr_SetString(PyExc_TypeError,
                    "vector<""std::string""> expected");
                    SWIG_fail;
                }
            }
        }else if (SWIG_ConvertPtr(obj0,(void **) &v1, 
        SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
            arg1 = v1;
        }else {
            PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
            SWIG_fail;
        }
    }
    {
        try {
            result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if ((argc >= 0) && (argc <= 1)) {
        int _v;
        if (argc <= 0) {
            return _wrap_new_vector_string__SWIG_0(self,args);
        }
        {
            _v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_vector_string__SWIG_0(self,args);
        }
    }
    if (argc == 1) {
        int _v;
        {
            /* native sequence? */
            if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
                unsigned int size = (PyTuple_Check(argv[0]) ?
                PyTuple_Size(argv[0]) :
                PyList_Size(argv[0]));
                if (size == 0) {
                    /* an empty sequence can be of any type */
                    _v = 1;
                }else {
                    /* check the first element only */
                    PyObject* o = PySequence_GetItem(argv[0],0);
                    if (PyString_Check(o))
                    _v = 1;
                    else
                    _v = 0;
                    Py_DECREF(o);
                }
            }else {
                /* wrapped vector? */
                std::vector<std::string >* v;
                if (SWIG_ConvertPtr(argv[0],(void **) &v, 
                SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
                _v = 1;
                else
                _v = 0;
            }
        }
        if (_v) {
            return _wrap_new_vector_string__SWIG_2(self,args);
        }
    }
    if (argc == 2) {
        int _v;
        {
            _v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
        }
        if (_v) {
            {
                _v = PyString_Check(argv[1]) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_vector_string__SWIG_1(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
    return NULL;
}


static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    unsigned int result;
    std::vector<std::string > temp1 ;
    std::vector<std::string > *v1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
    {
        if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
            unsigned int size = (PyTuple_Check(obj0) ?
            PyTuple_Size(obj0) :
            PyList_Size(obj0));
            temp1 = std::vector<std::string >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                PyObject* o = PySequence_GetItem(obj0,i);
                if (PyString_Check(o)) {
                    temp1[i] = (std::string)(\
                    SwigString_AsString(o));
                    Py_DECREF(o);
                }else {
                    Py_DECREF(o);
                    PyErr_SetString(PyExc_TypeError,
                    "vector<""std::string""> expected");
                    SWIG_fail;
                }
            }
        }else if (SWIG_ConvertPtr(obj0,(void **) &v1, 
        SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
            arg1 = v1;
        }else {
            PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
            SWIG_fail;
        }
    }
    {
        try {
            result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    bool result;
    std::vector<std::string > temp1 ;
    std::vector<std::string > *v1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
    {
        if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
            unsigned int size = (PyTuple_Check(obj0) ?
            PyTuple_Size(obj0) :
            PyList_Size(obj0));
            temp1 = std::vector<std::string >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                PyObject* o = PySequence_GetItem(obj0,i);
                if (PyString_Check(o)) {
                    temp1[i] = (std::string)(\
                    SwigString_AsString(o));
                    Py_DECREF(o);
                }else {
                    Py_DECREF(o);
                    PyErr_SetString(PyExc_TypeError,
                    "vector<""std::string""> expected");
                    SWIG_fail;
                }
            }
        }else if (SWIG_ConvertPtr(obj0,(void **) &v1, 
        SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
            arg1 = v1;
        }else {
            PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
            SWIG_fail;
        }
    }
    {
        try {
            result = (bool)((std::vector<std::string > const *)arg1)->empty();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            (arg1)->clear();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    std::string arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1))
        arg2 = std::string(PyString_AsString(obj1));
        else
        SWIG_exception(SWIG_TypeError, "string expected");
    }
    {
        try {
            (arg1)->push_back(arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    std::string result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = std_vectorlstd_string_g_pop___(arg1);
            
        }catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    {
        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    int arg2 ;
    std::string result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
            
        }catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    {
        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    int arg2 ;
    int arg3 ;
    std::vector<std::string > result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyTuple_New((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++)
        PyTuple_SetItem(resultobj,i,
        SwigString_FromString(((std::vector<std::string > &)result)[i]));
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    int arg2 ;
    std::string arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj2))
        arg3 = std::string(PyString_AsString(obj2));
        else
        SWIG_exception(SWIG_TypeError, "string expected");
    }
    {
        try {
            std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
            
        }catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    int arg2 ;
    int arg3 ;
    std::vector<std::string > *arg4 = 0 ;
    std::vector<std::string > temp4 ;
    std::vector<std::string > *v4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
            unsigned int size = (PyTuple_Check(obj3) ?
            PyTuple_Size(obj3) :
            PyList_Size(obj3));
            temp4 = std::vector<std::string >(size);
            arg4 = &temp4;
            for (unsigned int i=0; i<size; i++) {
                PyObject* o = PySequence_GetItem(obj3,i);
                if (PyString_Check(o)) {
                    temp4[i] = (std::string)(\
                    SwigString_AsString(o));
                    Py_DECREF(o);
                }else {
                    Py_DECREF(o);
                    PyErr_SetString(PyExc_TypeError,
                    "vector<""std::string""> expected");
                    SWIG_fail;
                }
            }
        }else if (SWIG_ConvertPtr(obj3,(void **) &v4, 
        SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
            arg4 = v4;
        }else {
            PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
            SWIG_fail;
        }
    }
    {
        try {
            std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    int arg2 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            std_vectorlstd_string_g___delitem_____(arg1,arg2);
            
        }catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    int arg2 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            delete arg1;
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::string arg1 = (std::string) "" ;
    std::string arg2 = (std::string) "2" ;
    std::string arg3 = (std::string) "" ;
    std::string arg4 = (std::string) "" ;
    BossSession *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
    if (obj0) {
        {
            if (PyString_Check(obj0))
            arg1 = std::string(PyString_AsString(obj0));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj1) {
        {
            if (PyString_Check(obj1))
            arg2 = std::string(PyString_AsString(obj1));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj2) {
        {
            if (PyString_Check(obj2))
            arg3 = std::string(PyString_AsString(obj2));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3))
            arg4 = std::string(PyString_AsString(obj3));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            delete arg1;
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            (arg1)->resetDB();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            (arg1)->clear();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string const &arg2_defvalue = "" ;
    std::string *arg2 = (std::string *) &arg2_defvalue ;
    BossTask *result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj1) {
        {
            if (PyString_Check(obj1)) {
                temp2 = std::string(PyString_AsString(obj1));
                arg2 = &temp2;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    {
        try {
            result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    BossTask *arg2 = (BossTask *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            (arg1)->destroyBossTask(arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::vector<std::string > result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (arg1)->showCHTools();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyTuple_New((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++)
        PyTuple_SetItem(resultobj,i,
        SwigString_FromString(((std::vector<std::string > &)result)[i]));
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::vector<std::string > result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (arg1)->showProgramTypes();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyTuple_New((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++)
        PyTuple_SetItem(resultobj,i,
        SwigString_FromString(((std::vector<std::string > &)result)[i]));
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::vector<std::string > result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (arg1)->showRTMon();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyTuple_New((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++)
        PyTuple_SetItem(resultobj,i,
        SwigString_FromString(((std::vector<std::string > &)result)[i]));
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::vector<std::string > result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (arg1)->showSchedulers();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyTuple_New((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++)
        PyTuple_SetItem(resultobj,i,
        SwigString_FromString(((std::vector<std::string > &)result)[i]));
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_defaultCHTool(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultCHTool",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (arg1)->defaultCHTool();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_defaultProgramType(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultProgramType",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (arg1)->defaultProgramType();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_defaultRTMon(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (arg1)->defaultRTMon();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_defaultScheduler(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultScheduler",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (arg1)->defaultScheduler();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_version(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (arg1)->version();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_clientID(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clientID",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (arg1)->clientID();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_showConfigs(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    bool arg2 = (bool) false ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_showConfigs",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj1) {
        arg2 = PyInt_AsLong(obj1) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (int)(arg1)->showConfigs(arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string arg2 = (std::string) "all" ;
    std::string arg3 = (std::string) "all" ;
    std::string arg4 = (std::string) "" ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossSession_RTupdate",&obj0,&obj1,&obj2,&obj3)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj1) {
        {
            if (PyString_Check(obj1))
            arg2 = std::string(PyString_AsString(obj1));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj2) {
        {
            if (PyString_Check(obj2))
            arg3 = std::string(PyString_AsString(obj2));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3))
            arg4 = std::string(PyString_AsString(obj3));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string *arg2 = 0 ;
    std::string *arg3 = 0 ;
    std::string const &arg4_defvalue = "" ;
    std::string *arg4 = (std::string *) &arg4_defvalue ;
    std::string const &arg5_defvalue = "" ;
    std::string *arg5 = (std::string *) &arg5_defvalue ;
    unsigned int arg6 = (unsigned int) 0 ;
    std::vector<std::string > result;
    std::string temp2 ;
    std::string temp3 ;
    std::string temp4 ;
    std::string temp5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        if (PyString_Check(obj2)) {
            temp3 = std::string(PyString_AsString(obj2));
            arg3 = &temp3;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3)) {
                temp4 = std::string(PyString_AsString(obj3));
                arg4 = &temp4;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4)) {
                temp5 = std::string(PyString_AsString(obj4));
                arg5 = &temp5;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj5) {
        arg6 = (unsigned int) PyInt_AsLong(obj5);
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyTuple_New((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++)
        PyTuple_SetItem(resultobj,i,
        SwigString_FromString(((std::vector<std::string > &)result)[i]));
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    int arg2 = (int) SCHEDULED ;
    std::string const &arg3_defvalue = "all" ;
    std::string *arg3 = (std::string *) &arg3_defvalue ;
    std::string const &arg4_defvalue = "all" ;
    std::string *arg4 = (std::string *) &arg4_defvalue ;
    std::string const &arg5_defvalue = "" ;
    std::string *arg5 = (std::string *) &arg5_defvalue ;
    std::string arg6 = (std::string) "" ;
    std::string arg7 = (std::string) "" ;
    std::string arg8 = (std::string) "" ;
    std::string arg9 = (std::string) "" ;
    unsigned int arg10 = (unsigned int) 0 ;
    std::string temp3 ;
    std::string temp4 ;
    std::string temp5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    PyObject * obj8 = 0 ;
    PyObject * obj9 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj2) {
        {
            if (PyString_Check(obj2)) {
                temp3 = std::string(PyString_AsString(obj2));
                arg3 = &temp3;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3)) {
                temp4 = std::string(PyString_AsString(obj3));
                arg4 = &temp4;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4)) {
                temp5 = std::string(PyString_AsString(obj4));
                arg5 = &temp5;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj5) {
        {
            if (PyString_Check(obj5))
            arg6 = std::string(PyString_AsString(obj5));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj6) {
        {
            if (PyString_Check(obj6))
            arg7 = std::string(PyString_AsString(obj6));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj7) {
        {
            if (PyString_Check(obj7))
            arg8 = std::string(PyString_AsString(obj7));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj8) {
        {
            if (PyString_Check(obj8))
            arg9 = std::string(PyString_AsString(obj8));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj9) {
        arg10 = (unsigned int) PyInt_AsLong(obj9);
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            (arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string const &arg2_defvalue = "all" ;
    std::string *arg2 = (std::string *) &arg2_defvalue ;
    std::string const &arg3_defvalue = "" ;
    std::string *arg3 = (std::string *) &arg3_defvalue ;
    std::string const &arg4_defvalue = "" ;
    std::string *arg4 = (std::string *) &arg4_defvalue ;
    std::string const &arg5_defvalue = "" ;
    std::string *arg5 = (std::string *) &arg5_defvalue ;
    std::vector<std::string > result;
    std::string temp2 ;
    std::string temp3 ;
    std::string temp4 ;
    std::string temp5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj1) {
        {
            if (PyString_Check(obj1)) {
                temp2 = std::string(PyString_AsString(obj1));
                arg2 = &temp2;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj2) {
        {
            if (PyString_Check(obj2)) {
                temp3 = std::string(PyString_AsString(obj2));
                arg3 = &temp3;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3)) {
                temp4 = std::string(PyString_AsString(obj3));
                arg4 = &temp4;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4)) {
                temp5 = std::string(PyString_AsString(obj4));
                arg5 = &temp5;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    {
        try {
            result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyTuple_New((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++)
        PyTuple_SetItem(resultobj,i,
        SwigString_FromString(((std::vector<std::string > &)result)[i]));
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_selectTasksByName(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string *arg2 = 0 ;
    std::vector<std::string > result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (arg1)->selectTasksByName((std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyTuple_New((&result)->size());
        for (unsigned int i=0; i<(&result)->size(); i++)
        PyTuple_SetItem(resultobj,i,
        SwigString_FromString(((std::vector<std::string > &)result)[i]));
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    int arg2 = (int) SCHEDULED ;
    std::string const &arg3_defvalue = "all" ;
    std::string *arg3 = (std::string *) &arg3_defvalue ;
    std::string const &arg4_defvalue = "all" ;
    std::string *arg4 = (std::string *) &arg4_defvalue ;
    std::string const &arg5_defvalue = "" ;
    std::string *arg5 = (std::string *) &arg5_defvalue ;
    std::string arg6 = (std::string) "" ;
    std::string arg7 = (std::string) "" ;
    std::string arg8 = (std::string) "" ;
    std::string arg9 = (std::string) "" ;
    unsigned int arg10 = (unsigned int) 0 ;
    bool arg11 = (bool) false ;
    SwigValueWrapper< std::vector<BossTask * > > result;
    std::string temp3 ;
    std::string temp4 ;
    std::string temp5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    PyObject * obj8 = 0 ;
    PyObject * obj9 = 0 ;
    PyObject * obj10 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj2) {
        {
            if (PyString_Check(obj2)) {
                temp3 = std::string(PyString_AsString(obj2));
                arg3 = &temp3;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3)) {
                temp4 = std::string(PyString_AsString(obj3));
                arg4 = &temp4;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4)) {
                temp5 = std::string(PyString_AsString(obj4));
                arg5 = &temp5;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj5) {
        {
            if (PyString_Check(obj5))
            arg6 = std::string(PyString_AsString(obj5));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj6) {
        {
            if (PyString_Check(obj6))
            arg7 = std::string(PyString_AsString(obj6));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj7) {
        {
            if (PyString_Check(obj7))
            arg8 = std::string(PyString_AsString(obj7));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj8) {
        {
            if (PyString_Check(obj8))
            arg9 = std::string(PyString_AsString(obj8));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj9) {
        arg10 = (unsigned int) PyInt_AsLong(obj9);
        if (PyErr_Occurred()) SWIG_fail;
    }
    if (obj10) {
        arg11 = PyInt_AsLong(obj10) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        std::vector<BossTask * > * resultptr;
        resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string *arg2 = 0 ;
    SwigValueWrapper< std::vector<BossTask * > > result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (arg1)->getTasksByName((std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        std::vector<BossTask * > * resultptr;
        resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string *arg2 = 0 ;
    SwigValueWrapper< std::vector<BossTask * > > result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (arg1)->getTasksByJobName((std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        std::vector<BossTask * > * resultptr;
        resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_tasksInMemory(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    unsigned int result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (unsigned int)(arg1)->tasksInMemory();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_locate(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    unsigned int arg2 ;
    BossTask *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_locate",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    arg2 = (unsigned int) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) SWIG_fail;
    {
        try {
            result = (BossTask *)(arg1)->locate(arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::vector<std::string > *arg2 = 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (arg2 == NULL) {
        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail; 
    }
    {
        try {
            result = (PyObject *)BossSession_show(arg1,*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (PyObject *)BossSession_CHTools(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (PyObject *)BossSession_ProgramTypes(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (PyObject *)BossSession_RTMons(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (PyObject *)BossSession_schedulers(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string *arg2 = 0 ;
    std::string *arg3 = 0 ;
    std::string const &arg4_defvalue = "" ;
    std::string *arg4 = (std::string *) &arg4_defvalue ;
    std::string const &arg5_defvalue = "" ;
    std::string *arg5 = (std::string *) &arg5_defvalue ;
    unsigned int arg6 = (unsigned int) 0 ;
    PyObject *result;
    std::string temp2 ;
    std::string temp3 ;
    std::string temp4 ;
    std::string temp5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        if (PyString_Check(obj2)) {
            temp3 = std::string(PyString_AsString(obj2));
            arg3 = &temp3;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3)) {
                temp4 = std::string(PyString_AsString(obj3));
                arg4 = &temp4;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4)) {
                temp5 = std::string(PyString_AsString(obj4));
                arg5 = &temp5;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj5) {
        arg6 = (unsigned int) PyInt_AsLong(obj5);
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossSession *arg1 = (BossSession *) 0 ;
    std::string const &arg2_defvalue = "" ;
    std::string *arg2 = (std::string *) &arg2_defvalue ;
    std::string const &arg3_defvalue = "all" ;
    std::string *arg3 = (std::string *) &arg3_defvalue ;
    std::string arg4 = (std::string) "" ;
    std::string arg5 = (std::string) "" ;
    std::string arg6 = (std::string) "" ;
    PyObject *result;
    std::string temp2 ;
    std::string temp3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj1) {
        {
            if (PyString_Check(obj1)) {
                temp2 = std::string(PyString_AsString(obj1));
                arg2 = &temp2;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj2) {
        {
            if (PyString_Check(obj2)) {
                temp3 = std::string(PyString_AsString(obj2));
                arg3 = &temp3;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3))
            arg4 = std::string(PyString_AsString(obj3));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4))
            arg5 = std::string(PyString_AsString(obj4));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj5) {
        {
            if (PyString_Check(obj5))
            arg6 = std::string(PyString_AsString(obj5));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    char *arg1 ;
    BossTaskException *result;
    
    if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
    {
        try {
            result = (BossTaskException *)new BossTaskException((char const *)arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTaskException *arg1 = (BossTaskException *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            delete arg1;
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    BossTask::job_iterator result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = ((BossTask const *)arg1)->job_begin();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        BossTask::job_iterator * resultptr;
        resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    BossTask::job_iterator result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = ((BossTask const *)arg1)->job_end();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        BossTask::job_iterator * resultptr;
        resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    BossJob *arg2 = (BossJob *) 0 ;
    SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
        resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    BossJob *arg2 = (BossJob *) 0 ;
    std::string *arg3 = 0 ;
    BossProgram result;
    std::string temp3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj2)) {
            temp3 = std::string(PyString_AsString(obj2));
            arg3 = &temp3;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = ((BossTask const *)arg1)->queryProgram((BossJob const *)arg2,(std::string const &)*arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        BossProgram * resultptr;
        resultptr = new BossProgram((BossProgram &) result);
        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_queryProgramExec(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    BossJob *arg2 = (BossJob *) 0 ;
    std::string *arg3 = 0 ;
    BossProgramExec result;
    std::string temp3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj2)) {
            temp3 = std::string(PyString_AsString(obj2));
            arg3 = &temp3;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = ((BossTask const *)arg1)->queryProgramExec((BossJob const *)arg2,(std::string const &)*arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        BossProgramExec * resultptr;
        resultptr = new BossProgramExec((BossProgramExec &) result);
        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossDatabase *arg1 = (BossDatabase *) 0 ;
    BossTask *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossDatabase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (BossTask *)new BossTask(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_new_BossTask__SWIG_1(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossDatabase *arg1 = (BossDatabase *) 0 ;
    std::string *arg2 = 0 ;
    BossTask *result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:new_BossTask",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossDatabase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_BossTask(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTask",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            delete arg1;
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_new_BossTask__SWIG_2(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = 0 ;
    BossTask *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (arg1 == NULL) {
        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail; 
    }
    {
        try {
            result = (BossTask *)new BossTask((BossTask const &)*arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_new_BossTask(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossDatabase, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            }else {
                _v = 1;
            }
        }
        if (_v) {
            return _wrap_new_BossTask__SWIG_0(self,args);
        }
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            }else {
                _v = 1;
            }
        }
        if (_v) {
            return _wrap_new_BossTask__SWIG_2(self,args);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossDatabase, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            }else {
                _v = 1;
            }
        }
        if (_v) {
            {
                _v = PyString_Check(argv[1]) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_BossTask__SWIG_1(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_BossTask'");
    return NULL;
}


static PyObject *_wrap_BossTask_id(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_id",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            {
                std::string const &_result_ref = ((BossTask const *)arg1)->id();
                result = (std::string *) &_result_ref;
            }
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyString_FromStringAndSize(result->data(),result->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_name(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_name",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            {
                std::string const &_result_ref = ((BossTask const *)arg1)->name();
                result = (std::string *) &_result_ref;
            }
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyString_FromStringAndSize(result->data(),result->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_chain(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *arg2 = 0 ;
    BossChain result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = ((BossTask const *)arg1)->chain((std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        BossChain * resultptr;
        resultptr = new BossChain((BossChain &) result);
        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::map<std::string,std::string > result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = ((BossTask const *)arg1)->taskMap();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyDict_New();
        for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
            PyDict_SetItem(resultobj,
            SwigString_FromString(i->first),
            SwigString_FromString(i->second));
        }
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = ((BossTask const *)arg1)->jobsMap();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        std::map<std::string,std::map<std::string,std::string > > * resultptr;
        resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
    std::map<std::string,std::string > *arg3 = 0 ;
    std::string result;
    std::vector<BossJob * >::const_iterator *argp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobMap",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
    arg2 = *argp2; 
    if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (arg3 == NULL) {
        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail; 
    }
    {
        try {
            result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    unsigned int arg2 ;
    std::map<std::string,std::string > result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    arg2 = (unsigned int) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) SWIG_fail;
    {
        try {
            result = ((BossTask const *)arg1)->jobMap(arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyDict_New();
        for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
            PyDict_SetItem(resultobj,
            SwigString_FromString(i->first),
            SwigString_FromString(i->second));
        }
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            }else {
                _v = 1;
            }
        }
        if (_v) {
            {
                _v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BossTask_jobMap__SWIG_1(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            }else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                }else {
                    _v = 1;
                }
            }
            if (_v) {
                {
                    void *ptr;
                    if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_std__mapTstd__string_std__string_t, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    }else {
                        _v = 1;
                    }
                }
                if (_v) {
                    return _wrap_BossTask_jobMap__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobMap'");
    return NULL;
}


static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    BossJob *arg2 = (BossJob *) 0 ;
    SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        std::map<std::string,std::map<std::string,std::string > > * resultptr;
        resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *arg2 = 0 ;
    std::string const &arg3_defvalue = "" ;
    std::string *arg3 = (std::string *) &arg3_defvalue ;
    std::string temp2 ;
    std::string temp3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_declare",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj2) {
        {
            if (PyString_Check(obj2)) {
                temp3 = std::string(PyString_AsString(obj2));
                arg3 = &temp3;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    {
        try {
            (arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_declare__SWIG_1(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    XMLDoc *arg2 = (XMLDoc *) 0 ;
    std::string const &arg3_defvalue = "" ;
    std::string *arg3 = (std::string *) &arg3_defvalue ;
    std::string temp3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_declare",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_XMLDoc,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj2) {
        {
            if (PyString_Check(obj2)) {
                temp3 = std::string(PyString_AsString(obj2));
                arg3 = &temp3;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    {
        try {
            (arg1)->declare(arg2,(std::string const &)*arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_declare(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if ((argc >= 2) && (argc <= 3)) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            }else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_XMLDoc, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                }else {
                    _v = 1;
                }
            }
            if (_v) {
                if (argc <= 2) {
                    return _wrap_BossTask_declare__SWIG_1(self,args);
                }
                {
                    _v = PyString_Check(argv[2]) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BossTask_declare__SWIG_1(self,args);
                }
            }
        }
    }
    if ((argc >= 2) && (argc <= 3)) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            }else {
                _v = 1;
            }
        }
        if (_v) {
            {
                _v = PyString_Check(argv[1]) ? 1 : 0;
            }
            if (_v) {
                if (argc <= 2) {
                    return _wrap_BossTask_declare__SWIG_0(self,args);
                }
                {
                    _v = PyString_Check(argv[2]) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BossTask_declare__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_declare'");
    return NULL;
}


static PyObject *_wrap_BossTask_remove(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_remove",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            (arg1)->remove();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_archive(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string const &arg2_defvalue = "all" ;
    std::string *arg2 = (std::string *) &arg2_defvalue ;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|O:BossTask_archive",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj1) {
        {
            if (PyString_Check(obj1)) {
                temp2 = std::string(PyString_AsString(obj1));
                arg2 = &temp2;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    {
        try {
            (arg1)->archive((std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string const &arg2_defvalue = "all" ;
    std::string *arg2 = (std::string *) &arg2_defvalue ;
    std::string const &arg3_defvalue = "" ;
    std::string *arg3 = (std::string *) &arg3_defvalue ;
    std::string const &arg4_defvalue = "" ;
    std::string *arg4 = (std::string *) &arg4_defvalue ;
    std::string const &arg5_defvalue = "" ;
    std::string *arg5 = (std::string *) &arg5_defvalue ;
    std::string const &arg6_defvalue = "" ;
    std::string *arg6 = (std::string *) &arg6_defvalue ;
    unsigned int arg7 = (unsigned int) 0 ;
    bool arg8 = (bool) false ;
    int result;
    std::string temp2 ;
    std::string temp3 ;
    std::string temp4 ;
    std::string temp5 ;
    std::string temp6 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj1) {
        {
            if (PyString_Check(obj1)) {
                temp2 = std::string(PyString_AsString(obj1));
                arg2 = &temp2;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj2) {
        {
            if (PyString_Check(obj2)) {
                temp3 = std::string(PyString_AsString(obj2));
                arg3 = &temp3;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3)) {
                temp4 = std::string(PyString_AsString(obj3));
                arg4 = &temp4;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4)) {
                temp5 = std::string(PyString_AsString(obj4));
                arg5 = &temp5;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj5) {
        {
            if (PyString_Check(obj5)) {
                temp6 = std::string(PyString_AsString(obj5));
                arg6 = &temp6;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj6) {
        arg7 = (unsigned int) PyInt_AsLong(obj6);
        if (PyErr_Occurred()) SWIG_fail;
    }
    if (obj7) {
        arg8 = PyInt_AsLong(obj7) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7,arg8);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_reSubmit(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *arg2 = 0 ;
    bool arg3 = (bool) false ;
    int result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_reSubmit",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj2) {
        arg3 = PyInt_AsLong(obj2) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_kill(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *arg2 = 0 ;
    unsigned int arg3 = (unsigned int) 0 ;
    bool arg4 = (bool) false ;
    int result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj2) {
        arg3 = (unsigned int) PyInt_AsLong(obj2);
        if (PyErr_Occurred()) SWIG_fail;
    }
    if (obj3) {
        arg4 = PyInt_AsLong(obj3) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string const &arg2_defvalue = "all" ;
    std::string *arg2 = (std::string *) &arg2_defvalue ;
    std::string const &arg3_defvalue = "" ;
    std::string *arg3 = (std::string *) &arg3_defvalue ;
    unsigned int arg4 = (unsigned int) 0 ;
    bool arg5 = (bool) false ;
    bool arg6 = (bool) false ;
    int result;
    std::string temp2 ;
    std::string temp3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj1) {
        {
            if (PyString_Check(obj1)) {
                temp2 = std::string(PyString_AsString(obj1));
                arg2 = &temp2;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj2) {
        {
            if (PyString_Check(obj2)) {
                temp3 = std::string(PyString_AsString(obj2));
                arg3 = &temp3;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj3) {
        arg4 = (unsigned int) PyInt_AsLong(obj3);
        if (PyErr_Occurred()) SWIG_fail;
    }
    if (obj4) {
        arg5 = PyInt_AsLong(obj4) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    if (obj5) {
        arg6 = PyInt_AsLong(obj5) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *arg2 = 0 ;
    int result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (int)(arg1)->loadByName((std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    int arg2 = (int) SCHEDULED ;
    std::string const &arg3_defvalue = "all" ;
    std::string *arg3 = (std::string *) &arg3_defvalue ;
    std::string const &arg4_defvalue = "" ;
    std::string *arg4 = (std::string *) &arg4_defvalue ;
    std::string arg5 = (std::string) "" ;
    std::string arg6 = (std::string) "" ;
    std::string arg7 = (std::string) "" ;
    std::string arg8 = (std::string) "" ;
    int result;
    std::string temp3 ;
    std::string temp4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj2) {
        {
            if (PyString_Check(obj2)) {
                temp3 = std::string(PyString_AsString(obj2));
                arg3 = &temp3;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3)) {
                temp4 = std::string(PyString_AsString(obj3));
                arg4 = &temp4;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4))
            arg5 = std::string(PyString_AsString(obj4));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj5) {
        {
            if (PyString_Check(obj5))
            arg6 = std::string(PyString_AsString(obj5));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj6) {
        {
            if (PyString_Check(obj6))
            arg7 = std::string(PyString_AsString(obj6));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj7) {
        {
            if (PyString_Check(obj7))
            arg8 = std::string(PyString_AsString(obj7));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_schedulerQuery(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    int arg2 = (int) SCHEDULED ;
    std::string const &arg3_defvalue = "all" ;
    std::string *arg3 = (std::string *) &arg3_defvalue ;
    std::string const &arg4_defvalue = "" ;
    std::string *arg4 = (std::string *) &arg4_defvalue ;
    std::string arg5 = (std::string) "" ;
    std::string arg6 = (std::string) "" ;
    std::string arg7 = (std::string) "" ;
    std::string arg8 = (std::string) "" ;
    unsigned int arg9 = (unsigned int) 0 ;
    int result;
    std::string temp3 ;
    std::string temp4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    PyObject * obj8 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj2) {
        {
            if (PyString_Check(obj2)) {
                temp3 = std::string(PyString_AsString(obj2));
                arg3 = &temp3;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3)) {
                temp4 = std::string(PyString_AsString(obj3));
                arg4 = &temp4;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4))
            arg5 = std::string(PyString_AsString(obj4));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj5) {
        {
            if (PyString_Check(obj5))
            arg6 = std::string(PyString_AsString(obj5));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj6) {
        {
            if (PyString_Check(obj6))
            arg7 = std::string(PyString_AsString(obj6));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj7) {
        {
            if (PyString_Check(obj7))
            arg8 = std::string(PyString_AsString(obj7));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj8) {
        arg9 = (unsigned int) PyInt_AsLong(obj8);
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    int arg2 = (int) SCHEDULED ;
    std::string const &arg3_defvalue = "all" ;
    std::string *arg3 = (std::string *) &arg3_defvalue ;
    std::string const &arg4_defvalue = "" ;
    std::string *arg4 = (std::string *) &arg4_defvalue ;
    std::string arg5 = (std::string) "" ;
    std::string arg6 = (std::string) "" ;
    std::string arg7 = (std::string) "" ;
    std::string arg8 = (std::string) "" ;
    unsigned int arg9 = (unsigned int) 0 ;
    bool arg10 = (bool) false ;
    int result;
    std::string temp3 ;
    std::string temp4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    PyObject * obj8 = 0 ;
    PyObject * obj9 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj2) {
        {
            if (PyString_Check(obj2)) {
                temp3 = std::string(PyString_AsString(obj2));
                arg3 = &temp3;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3)) {
                temp4 = std::string(PyString_AsString(obj3));
                arg4 = &temp4;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4))
            arg5 = std::string(PyString_AsString(obj4));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj5) {
        {
            if (PyString_Check(obj5))
            arg6 = std::string(PyString_AsString(obj5));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj6) {
        {
            if (PyString_Check(obj6))
            arg7 = std::string(PyString_AsString(obj6));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj7) {
        {
            if (PyString_Check(obj7))
            arg8 = std::string(PyString_AsString(obj7));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj8) {
        arg9 = (unsigned int) PyInt_AsLong(obj8);
        if (PyErr_Occurred()) SWIG_fail;
    }
    if (obj9) {
        arg10 = PyInt_AsLong(obj9) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_query_out(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::ostream &arg2_defvalue = std::cout ;
    std::ostream *arg2 = (std::ostream *) &arg2_defvalue ;
    jobStates const &arg3_defvalue = SCHEDULED ;
    jobStates *arg3 = (jobStates *) &arg3_defvalue ;
    printOption const &arg4_defvalue = NORMAL ;
    printOption *arg4 = (printOption *) &arg4_defvalue ;
    std::string arg5 = (std::string) "" ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_query_out",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (obj1) {
        if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
        if (arg2 == NULL) {
            PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail; 
        }
    }
    if (obj2) {
        if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
        if (arg3 == NULL) {
            PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail; 
        }
    }
    if (obj3) {
        if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
        if (arg4 == NULL) {
            PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail; 
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4))
            arg5 = std::string(PyString_AsString(obj4));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            ((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_clear(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_clear",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            (arg1)->clear();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    PyObject *arg2 = (PyObject *) 0 ;
    BossAttributeContainer *arg3 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    arg2 = obj1;
    if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (arg3 == NULL) {
        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail; 
    }
    {
        try {
            BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    BossJob *arg2 = (BossJob *) 0 ;
    PyObject *arg3 = (PyObject *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    arg3 = obj2;
    {
        try {
            BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (PyObject *)BossTask_jobsDict(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *arg2 = 0 ;
    PyObject *result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (PyObject *)BossTask_job(arg1,(std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_Chain(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *arg2 = 0 ;
    PyObject *result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (PyObject *)BossTask_Chain(arg1,(std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (PyObject *)BossTask_jobStates(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (PyObject *)BossTask_jobStatistic(arg1);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    if (arg2 == NULL) {
        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail; 
    }
    {
        try {
            result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *arg2 = 0 ;
    PyObject *result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_program(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *arg2 = 0 ;
    std::string *arg3 = 0 ;
    PyObject *result;
    std::string temp2 ;
    std::string temp3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        if (PyString_Check(obj2)) {
            temp3 = std::string(PyString_AsString(obj2));
            arg3 = &temp3;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (PyObject *)BossTask_program(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_programExec(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *arg2 = 0 ;
    std::string *arg3 = 0 ;
    PyObject *result;
    std::string temp2 ;
    std::string temp3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        if (PyString_Check(obj2)) {
            temp3 = std::string(PyString_AsString(obj2));
            arg3 = &temp3;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (PyObject *)BossTask_programExec(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossTask_specific(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossTask *arg1 = (BossTask *) 0 ;
    std::string *arg2 = 0 ;
    std::string *arg3 = 0 ;
    PyObject *result;
    std::string temp2 ;
    std::string temp3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        if (PyString_Check(obj2)) {
            temp3 = std::string(PyString_AsString(obj2));
            arg3 = &temp3;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (PyObject *)BossTask_specific(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    std::string arg1 = (std::string) "" ;
    std::string arg2 = (std::string) "2" ;
    std::string arg3 = (std::string) "" ;
    std::string arg4 = (std::string) "" ;
    bool arg5 = (bool) false ;
    BossAdministratorSession *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    if (obj0) {
        {
            if (PyString_Check(obj0))
            arg1 = std::string(PyString_AsString(obj0));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj1) {
        {
            if (PyString_Check(obj1))
            arg2 = std::string(PyString_AsString(obj1));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj2) {
        {
            if (PyString_Check(obj2))
            arg3 = std::string(PyString_AsString(obj2));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3))
            arg4 = std::string(PyString_AsString(obj3));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj4) {
        arg5 = PyInt_AsLong(obj4) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_BossAdministratorSession(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_BossAdministratorSession",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            delete arg1;
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (int)(arg1)->configureDB();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string *arg2 = 0 ;
    int result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureRTMonDB",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_deleteCHTool(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string *arg2 = 0 ;
    int result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteCHTool",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_deleteProgramType(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string *arg2 = 0 ;
    int result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteProgramType",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_deleteRTMon(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string *arg2 = 0 ;
    int result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteRTMon",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_deleteScheduler(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string *arg2 = 0 ;
    int result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteScheduler",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        try {
            result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_registerCHTool(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string *arg2 = 0 ;
    std::string arg3 = (std::string) "NULL" ;
    std::string arg4 = (std::string) "NULL" ;
    bool arg5 = (bool) false ;
    bool arg6 = (bool) false ;
    int result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj2) {
        {
            if (PyString_Check(obj2))
            arg3 = std::string(PyString_AsString(obj2));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3))
            arg4 = std::string(PyString_AsString(obj3));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj4) {
        arg5 = PyInt_AsLong(obj4) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    if (obj5) {
        arg6 = PyInt_AsLong(obj5) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_registerProgram(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string *arg2 = 0 ;
    std::string arg3 = (std::string) "NULL" ;
    std::string arg4 = (std::string) "NULL" ;
    std::string arg5 = (std::string) "NULL" ;
    std::string arg6 = (std::string) "NULL" ;
    std::string arg7 = (std::string) "" ;
    bool arg8 = (bool) false ;
    int result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj2) {
        {
            if (PyString_Check(obj2))
            arg3 = std::string(PyString_AsString(obj2));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3))
            arg4 = std::string(PyString_AsString(obj3));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4))
            arg5 = std::string(PyString_AsString(obj4));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj5) {
        {
            if (PyString_Check(obj5))
            arg6 = std::string(PyString_AsString(obj5));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj6) {
        {
            if (PyString_Check(obj6))
            arg7 = std::string(PyString_AsString(obj6));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj7) {
        arg8 = PyInt_AsLong(obj7) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_registerRTMon(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string *arg2 = 0 ;
    std::string arg3 = (std::string) "NULL" ;
    std::string arg4 = (std::string) "NULL" ;
    std::string arg5 = (std::string) "NULL" ;
    bool arg6 = (bool) false ;
    bool arg7 = (bool) false ;
    int result;
    std::string temp2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO|OOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj2) {
        {
            if (PyString_Check(obj2))
            arg3 = std::string(PyString_AsString(obj2));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3))
            arg4 = std::string(PyString_AsString(obj3));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4))
            arg5 = std::string(PyString_AsString(obj4));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj5) {
        arg6 = PyInt_AsLong(obj5) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    if (obj6) {
        arg7 = PyInt_AsLong(obj6) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_registerScheduler(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string *arg2 = 0 ;
    std::string arg3 = (std::string) "NULL" ;
    std::string arg4 = (std::string) "NULL" ;
    std::string arg5 = (std::string) "NULL" ;
    std::string arg6 = (std::string) "NULL" ;
    std::string arg7 = (std::string) "" ;
    std::string arg8 = (std::string) "" ;
    std::string arg9 = (std::string) "" ;
    std::string arg10 = (std::string) "" ;
    std::string const &arg11_defvalue = "" ;
    std::string *arg11 = (std::string *) &arg11_defvalue ;
    std::string arg12 = (std::string) "" ;
    std::string arg13 = (std::string) "" ;
    bool arg14 = (bool) false ;
    bool arg15 = (bool) false ;
    bool arg16 = (bool) false ;
    bool arg17 = (bool) false ;
    int result;
    std::string temp2 ;
    std::string temp11 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    PyObject * obj8 = 0 ;
    PyObject * obj9 = 0 ;
    PyObject * obj10 = 0 ;
    PyObject * obj11 = 0 ;
    PyObject * obj12 = 0 ;
    PyObject * obj13 = 0 ;
    PyObject * obj14 = 0 ;
    PyObject * obj15 = 0 ;
    PyObject * obj16 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj2) {
        {
            if (PyString_Check(obj2))
            arg3 = std::string(PyString_AsString(obj2));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj3) {
        {
            if (PyString_Check(obj3))
            arg4 = std::string(PyString_AsString(obj3));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4))
            arg5 = std::string(PyString_AsString(obj4));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj5) {
        {
            if (PyString_Check(obj5))
            arg6 = std::string(PyString_AsString(obj5));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj6) {
        {
            if (PyString_Check(obj6))
            arg7 = std::string(PyString_AsString(obj6));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj7) {
        {
            if (PyString_Check(obj7))
            arg8 = std::string(PyString_AsString(obj7));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj8) {
        {
            if (PyString_Check(obj8))
            arg9 = std::string(PyString_AsString(obj8));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj9) {
        {
            if (PyString_Check(obj9))
            arg10 = std::string(PyString_AsString(obj9));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj10) {
        {
            if (PyString_Check(obj10)) {
                temp11 = std::string(PyString_AsString(obj10));
                arg11 = &temp11;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    if (obj11) {
        {
            if (PyString_Check(obj11))
            arg12 = std::string(PyString_AsString(obj11));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj12) {
        {
            if (PyString_Check(obj12))
            arg13 = std::string(PyString_AsString(obj12));
            else
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj13) {
        arg14 = PyInt_AsLong(obj13) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    if (obj14) {
        arg15 = PyInt_AsLong(obj14) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    if (obj15) {
        arg16 = PyInt_AsLong(obj15) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    if (obj16) {
        arg17 = PyInt_AsLong(obj16) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15,arg16,arg17);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_help(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_help",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        try {
            result = (arg1)->help();
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string arg2 ;
    bool arg3 = (bool) false ;
    std::string result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1))
        arg2 = std::string(PyString_AsString(obj1));
        else
        SWIG_exception(SWIG_TypeError, "string expected");
    }
    if (obj2) {
        arg3 = PyInt_AsLong(obj2) ? true : false;
        if (PyErr_Occurred()) SWIG_fail;
    }
    {
        try {
            result = (arg1)->SQL(arg2,arg3);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    {
        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string *arg2 = 0 ;
    std::string *arg3 = 0 ;
    std::string *arg4 = 0 ;
    std::string const &arg5_defvalue = "0" ;
    std::string *arg5 = (std::string *) &arg5_defvalue ;
    int result;
    std::string temp2 ;
    std::string temp3 ;
    std::string temp4 ;
    std::string temp5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1)) {
            temp2 = std::string(PyString_AsString(obj1));
            arg2 = &temp2;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        if (PyString_Check(obj2)) {
            temp3 = std::string(PyString_AsString(obj2));
            arg3 = &temp3;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    {
        if (PyString_Check(obj3)) {
            temp4 = std::string(PyString_AsString(obj3));
            arg4 = &temp4;
        }else {
            SWIG_exception(SWIG_TypeError, "string expected");
        }
    }
    if (obj4) {
        {
            if (PyString_Check(obj4)) {
                temp5 = std::string(PyString_AsString(obj4));
                arg5 = &temp5;
            }else {
                SWIG_exception(SWIG_TypeError, "string expected");
            }
        }
    }
    {
        try {
            result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
    std::string arg2 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
    {
        if (PyString_Check(obj1))
        arg2 = std::string(PyString_AsString(obj1));
        else
        SWIG_exception(SWIG_TypeError, "string expected");
    }
    {
        try {
            result = (int)(arg1)->registerPlugins(arg2);
            
        }catch (const BossSchedFailure & e) {
            PyErr_SetString ( SchedulerError, e.what() );
            return NULL;
        }catch (const std::exception& e) {
            PyErr_SetString ( BossError, e.what() );
            return NULL;
        }
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject * BossAdministratorSession_swigregister(PyObject *self, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_BossAdministratorSession, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyMethodDef SwigMethods[] = {
         { (char *)"new_objectMap", _wrap_new_objectMap, METH_VARARGS },
         { (char *)"objectMap___len__", _wrap_objectMap___len__, METH_VARARGS },
         { (char *)"objectMap_clear", _wrap_objectMap_clear, METH_VARARGS },
         { (char *)"objectMap___nonzero__", _wrap_objectMap___nonzero__, METH_VARARGS },
         { (char *)"objectMap___getitem__", _wrap_objectMap___getitem__, METH_VARARGS },
         { (char *)"objectMap___setitem__", _wrap_objectMap___setitem__, METH_VARARGS },
         { (char *)"objectMap___delitem__", _wrap_objectMap___delitem__, METH_VARARGS },
         { (char *)"objectMap_has_key", _wrap_objectMap_has_key, METH_VARARGS },
         { (char *)"objectMap_keys", _wrap_objectMap_keys, METH_VARARGS },
         { (char *)"objectMap_values", _wrap_objectMap_values, METH_VARARGS },
         { (char *)"objectMap_items", _wrap_objectMap_items, METH_VARARGS },
         { (char *)"objectMap___contains__", _wrap_objectMap___contains__, METH_VARARGS },
         { (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
         { (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
         { (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
         { (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
         { (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
         { (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
         { (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
         { (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
         { (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
         { (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
         { (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
         { (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
         { (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
         { (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
         { (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
         { (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
         { (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
         { (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
         { (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
         { (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
         { (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
         { (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
         { (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
         { (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
         { (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
         { (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
         { (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
         { (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
         { (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
         { (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
         { (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS },
         { (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
         { (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
         { (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
         { (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
         { (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
         { (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
         { (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
         { (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
         { (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
         { (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
         { (char *)"BossSession_getTasksByJobName", _wrap_BossSession_getTasksByJobName, METH_VARARGS },
         { (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
         { (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
         { (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
         { (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
         { (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
         { (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
         { (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
         { (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
         { (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
         { (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
         { (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
         { (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
         { (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
         { (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
         { (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
         { (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
         { (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
         { (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
         { (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
         { (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
         { (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
         { (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
         { (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
         { (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
         { (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
         { (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
         { (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
         { (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
         { (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
         { (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
         { (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
         { (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
         { (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
         { (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
         { (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
         { (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
         { (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
         { (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
         { (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
         { (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
         { (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
         { (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
         { (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
         { (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
         { (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
         { (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
         { (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
         { (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
         { (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
         { (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
         { (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
         { (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
         { (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
         { (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
         { (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
         { (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
         { (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
         { (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
         { (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
         { (char *)"BossAdministratorSession_deleteRTMon", _wrap_BossAdministratorSession_deleteRTMon, METH_VARARGS },
         { (char *)"BossAdministratorSession_deleteScheduler", _wrap_BossAdministratorSession_deleteScheduler, METH_VARARGS },
         { (char *)"BossAdministratorSession_registerCHTool", _wrap_BossAdministratorSession_registerCHTool, METH_VARARGS },
         { (char *)"BossAdministratorSession_registerProgram", _wrap_BossAdministratorSession_registerProgram, METH_VARARGS },
         { (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
         { (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
         { (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
         { (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
         { (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
         { (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
         { (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
         { NULL, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t", 0, "std::vector<std::pair<BossProgram,BossProgramExec > > *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t"},{0}};
static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator", 0, "std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator"},{0}};
static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
static swig_type_info _swigt__p_std__vectorTBossTask_p_t[] = {{"_p_std__vectorTBossTask_p_t", 0, "std::vector<BossTask * > *", 0},{"_p_std__vectorTBossTask_p_t"},{0}};
static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
static swig_type_info _swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t[] = {{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t", 0, "std::map<std::string,std::map<std::string,std::string > > *", 0},{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t"},{0}};
static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
static swig_type_info _swigt__p_std__vectorTstd__string_t[] = {{"_p_std__vectorTstd__string_t", 0, "std::vector<std::string > *", 0},{"_p_std__vectorTstd__string_t"},{0}};
static swig_type_info _swigt__p_std__mapTstd__string_std__string_t[] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0},{"_p_std__mapTstd__string_std__string_t"},{0}};
static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};

static swig_type_info *swig_types_initial[] = {
_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 
_swigt__p_XMLDoc, 
_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator, 
_swigt__p_BossProgramExec, 
_swigt__p_std__vectorTBossTask_p_t, 
_swigt__p_BossChain, 
_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 
_swigt__p_BossTask, 
_swigt__p_BossTaskException, 
_swigt__p_std__ostream, 
_swigt__p_BossProgram, 
_swigt__p_printOption, 
_swigt__p_BossAttributeContainer, 
_swigt__p_BossJob, 
_swigt__p_BossDatabase, 
_swigt__p_BossSession, 
_swigt__p_std__vectorTstd__string_t, 
_swigt__p_std__mapTstd__string_std__string_t, 
_swigt__p_BossAdministratorSession, 
_swigt__p_BossTask__job_iterator, 
_swigt__p_std__vectorTBossJob_p_t__const_iterator, 
_swigt__p_jobStates, 
0
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{ SWIG_PY_INT,     (char *)"RUNNING", (long) RUNNING, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"SCHEDULED", (long) SCHEDULED, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"SUBMITTED", (long) SUBMITTED, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"ALL", (long) ALL, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"STATUS_ONLY", (long) STATUS_ONLY, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"NORMAL", (long) NORMAL, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"SPECIFIC", (long) SPECIFIC, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"PROGRAMS", (long) PROGRAMS, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"FULL", (long) FULL, 0, 0, 0},
{0}};

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT(void) SWIG_init(void) {
    static PyObject *SWIG_globals = 0; 
    static int       typeinit = 0;
    PyObject *m, *d;
    int       i;
    if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
    m = Py_InitModule((char *) SWIG_name, SwigMethods);
    d = PyModule_GetDict(m);
    
    if (!typeinit) {
        for (i = 0; swig_types_initial[i]; i++) {
            swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
        }
        typeinit = 1;
    }
    SWIG_InstallConstants(d,swig_const_table);
    
    
    // define custom exceptions
    PyObject *e;
    PyMethodDef tp_methods = {
        NULL, NULL, 0, NULL
    };
    e = Py_InitModule("BossSession", &tp_methods);
    // generic BOSS exception
    BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
    Py_INCREF(BossError);
    PyModule_AddObject(e, "BossError", BossError);
    // scheduler interaction BOSS exception
    SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
    Py_INCREF(SchedulerError);
    PyModule_AddObject(e, "SchedulerError", SchedulerError);
    
}

Revision:	1.33
Committed:	Fri Jun 8 15:49:19 2007 UTC (17 years, 10 months ago) by gcodispo
Content type:	text/plain
Branch:	MAIN
CVS Tags:	BOSS_4_3_5
Changes since 1.32:	+18 -31 lines
Log Message:	Removed useless option leaving tmp files in the work directory (eventual dump in the logfile)