ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/COMP/BOSS/BossPython/BossSession_wrap.cxx
(Generate patch)

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.4 by gcodispo, Thu Oct 26 13:17:48 2006 UTC vs.
Revision 1.17 by gcodispo, Thu Dec 7 09:31:22 2006 UTC

# Line 654 | Line 654 | SWIG_InstallConstants(PyObject *d, swig_
654  
655   /* -------- TYPES TABLE (BEGIN) -------- */
656  
657 < #define  SWIGTYPE_p_std__vectorTBossJob_p_t swig_types[0]
657 > #define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[0]
658   #define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[1]
659 < #define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[2]
660 < #define  SWIGTYPE_p_XMLDoc swig_types[3]
659 > #define  SWIGTYPE_p_XMLDoc swig_types[2]
660 > #define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[3]
661   #define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[4]
662 < #define  SWIGTYPE_p_std__ostream swig_types[5]
663 < #define  SWIGTYPE_p_BossTask swig_types[6]
664 < #define  SWIGTYPE_p_BossTaskException swig_types[7]
665 < #define  SWIGTYPE_p_std__string swig_types[8]
666 < #define  SWIGTYPE_p_BossAttributeContainer swig_types[9]
667 < #define  SWIGTYPE_p_printOption swig_types[10]
662 > #define  SWIGTYPE_p_BossTask swig_types[5]
663 > #define  SWIGTYPE_p_BossTaskException swig_types[6]
664 > #define  SWIGTYPE_p_std__ostream swig_types[7]
665 > #define  SWIGTYPE_p_BossAttributeContainer swig_types[8]
666 > #define  SWIGTYPE_p_printOption swig_types[9]
667 > #define  SWIGTYPE_p_BossJob swig_types[10]
668   #define  SWIGTYPE_p_BossDatabase swig_types[11]
669 < #define  SWIGTYPE_p_BossJob swig_types[12]
670 < #define  SWIGTYPE_p_BossSession swig_types[13]
671 < #define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[14]
672 < #define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[15]
673 < #define  SWIGTYPE_p_BossAdministratorSession swig_types[16]
674 < #define  SWIGTYPE_p_jobStates swig_types[17]
675 < #define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[18]
676 < #define  SWIGTYPE_p_BossTask__job_iterator swig_types[19]
677 < static swig_type_info *swig_types[21];
669 > #define  SWIGTYPE_p_BossSession swig_types[12]
670 > #define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[13]
671 > #define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[14]
672 > #define  SWIGTYPE_p_BossAdministratorSession swig_types[15]
673 > #define  SWIGTYPE_p_BossTask__job_iterator swig_types[16]
674 > #define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[17]
675 > #define  SWIGTYPE_p_jobStates swig_types[18]
676 > static swig_type_info *swig_types[20];
677  
678   /* -------- TYPES TABLE (END) -------- */
679  
# Line 852 | Line 851 | PyObject *std_maplstd_stringcstd_string_
851                                           " for iterator support");
852                  #endif
853              }
854 + std::string std_vectorlstd_string_g_pop___(std::vector<std::string > *self){
855 +                if (self->size() == 0)
856 +                    throw std::out_of_range("pop from empty vector");
857 +                std::string x = self->back();
858 +                self->pop_back();
859 +                return x;
860 +            }
861 + std::string std_vectorlstd_string_g___getitem_____(std::vector<std::string > *self,int i){
862 +                int size = int(self->size());
863 +                if (i<0) i += size;
864 +                if (i>=0 && i<size)
865 +                    return (*self)[i];
866 +                else
867 +                    throw std::out_of_range("vector index out of range");
868 +            }
869 + std::vector<std::string > std_vectorlstd_string_g___getslice_____(std::vector<std::string > *self,int i,int j){
870 +                int size = int(self->size());
871 +                if (i<0) i = size+i;
872 +                if (j<0) j = size+j;
873 +                if (i<0) i = 0;
874 +                if (j>size) j = size;
875 +                std::vector<std::string > tmp(j-i);
876 +                std::copy(self->begin()+i,self->begin()+j,tmp.begin());
877 +                return tmp;
878 +            }
879 + void std_vectorlstd_string_g___setitem_____(std::vector<std::string > *self,int i,std::string x){
880 +                int size = int(self->size());
881 +                if (i<0) i+= size;
882 +                if (i>=0 && i<size)
883 +                    (*self)[i] = x;
884 +                else
885 +                    throw std::out_of_range("vector index out of range");
886 +            }
887 + void std_vectorlstd_string_g___setslice_____(std::vector<std::string > *self,int i,int j,std::vector<std::string > const &v){
888 +                int size = int(self->size());
889 +                if (i<0) i = size+i;
890 +                if (j<0) j = size+j;
891 +                if (i<0) i = 0;
892 +                if (j>size) j = size;
893 +                if (int(v.size()) == j-i) {
894 +                    std::copy(v.begin(),v.end(),self->begin()+i);
895 +                } else {
896 +                    self->erase(self->begin()+i,self->begin()+j);
897 +                    if (i+1 <= int(self->size()))
898 +                        self->insert(self->begin()+i,v.begin(),v.end());
899 +                    else
900 +                        self->insert(self->end(),v.begin(),v.end());
901 +                }
902 +            }
903 + void std_vectorlstd_string_g___delitem_____(std::vector<std::string > *self,int i){
904 +                int size = int(self->size());
905 +                if (i<0) i+= size;
906 +                if (i>=0 && i<size)
907 +                    self->erase(self->begin()+i);
908 +                else
909 +                    throw std::out_of_range("vector index out of range");
910 +            }
911 + void std_vectorlstd_string_g___delslice_____(std::vector<std::string > *self,int i,int j){
912 +                int size = int(self->size());
913 +                if (i<0) i = size+i;
914 +                if (j<0) j = size+j;
915 +                if (i<0) i = 0;
916 +                if (j>size) j = size;
917 +                self->erase(self->begin()+i,self->begin()+j);
918 +            }
919  
920   #include "BossSession.h"
921   #include "BossAdministratorSession.h"
# Line 863 | Line 927 | PyObject *std_maplstd_stringcstd_string_
927   #include "BossProgram.h"
928   #include "BossProgramExec.h"
929   #include "BossDatabase.h"
930 + #include "BossScheduler.h"
931  
932   PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
933      PyObject *  my_list = PyList_New( my_vec.size());
# Line 873 | Line 938 | PyObject *BossSession_show(BossSession *
938      }
939      return my_list;
940    }
941 < PyObject *BossSession_showCHTools__SWIG_1(BossSession *self){
941 > PyObject *BossSession_CHTools(BossSession *self){
942      std::vector<std::string> my_vec = self->showCHTools();
943      return BossSession_show( self, my_vec );
944    }
945 < PyObject *BossSession_showProgramTypes__SWIG_1(BossSession *self){
945 > PyObject *BossSession_ProgramTypes(BossSession *self){
946      std::vector<std::string> my_vec = self->showProgramTypes();
947      return BossSession_show( self, my_vec );
948    }
949 < PyObject *BossSession_showRTMon__SWIG_1(BossSession *self){
949 > PyObject *BossSession_RTMons(BossSession *self){
950      std::vector<std::string> my_vec = self->showRTMon();
951      return BossSession_show( self, my_vec );
952    }
953 < PyObject *BossSession_showSchedulers__SWIG_1(BossSession *self){
953 > PyObject *BossSession_schedulers(BossSession *self){
954      std::vector<std::string> my_vec = self->showSchedulers();
955      return BossSession_show( self, my_vec );
956    }
957 + PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
958 +    std::vector<std::string> my_vec = self->listMatch( scheduler,
959 +                                                       schclassad,
960 +                                                       keepfile,
961 +                                                       taskid,
962 +                                                       jobid);
963 +    return BossSession_show( self, my_vec );
964 +  }
965   PyObject *BossSession_queryTasks(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,bool avoidCheck){
966 <       self->jobQuery ( filter_opt, taskRange, jobRange, subn,
967 <                        type, user, after, before, avoidCheck);
966 >       if ( !avoidCheck ) {
967 >         self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
968 >                                type, user, after, before);
969 >       }
970         PyObject * job_dict = PyList_New(0);
971         std::vector <std::string>
972           taskList = self->selectTasks( taskRange, before, after, user);
# Line 899 | Line 974 | PyObject *BossSession_queryTasks(BossSes
974              it!= taskList.end(); ++it ) {
975           PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
976        }
902 –      
903 – //       int size = taskList.size();
904 – //       PyObject * job_dict = PyList_New(0);
905 – //       for ( unsigned int i = 0; i < size; ++i ) {
906 – //      PyList_SetItem(job_dict,i, );
907 – //      self->makeBossTask( *it );
908 – //       }
977         return  job_dict;
978       }
979   PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
# Line 945 | Line 1013 | PyObject *BossTask_jobDict(BossTask cons
1013      }
1014      return job_dict;
1015    }
1016 < PyObject *BossTask_jobsMap__SWIG_1(BossTask const *self){
1016 > PyObject *BossTask_jobsDict(BossTask *self){
1017    
1018      PyObject * job_dict = PyDict_New();
1019 +    if ( self->job_begin () == self->job_end ()) self->load(ALL);
1020      for (BossTask::job_iterator jit = self->job_begin ();
1021           jit != self->job_end (); ++jit) {
1022        std::string id = (*jit)->chainId();
# Line 1016 | Line 1085 | static PyObject *_wrap_new_objectMap__SW
1085          try {
1086              result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1087              
1088 +        }catch (const BossSchedFailure & e) {
1089 +            SWIG_exception(SWIG_ValueError, e.what());
1090          }catch (const std::exception& e) {
1091              SWIG_exception(SWIG_RuntimeError, e.what());
1092          }
# Line 1075 | Line 1146 | static PyObject *_wrap_new_objectMap__SW
1146          try {
1147              result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1148              
1149 +        }catch (const BossSchedFailure & e) {
1150 +            SWIG_exception(SWIG_ValueError, e.what());
1151          }catch (const std::exception& e) {
1152              SWIG_exception(SWIG_RuntimeError, e.what());
1153          }
# Line 1190 | Line 1263 | static PyObject *_wrap_objectMap___len__
1263          try {
1264              result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1265              
1266 +        }catch (const BossSchedFailure & e) {
1267 +            SWIG_exception(SWIG_ValueError, e.what());
1268          }catch (const std::exception& e) {
1269              SWIG_exception(SWIG_RuntimeError, e.what());
1270          }
# Line 1212 | Line 1287 | static PyObject *_wrap_objectMap_clear(P
1287          try {
1288              (arg1)->clear();
1289              
1290 +        }catch (const BossSchedFailure & e) {
1291 +            SWIG_exception(SWIG_ValueError, e.what());
1292          }catch (const std::exception& e) {
1293              SWIG_exception(SWIG_RuntimeError, e.what());
1294          }
# Line 1235 | Line 1312 | static PyObject *_wrap_objectMap___nonze
1312          try {
1313              result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1314              
1315 +        }catch (const BossSchedFailure & e) {
1316 +            SWIG_exception(SWIG_ValueError, e.what());
1317          }catch (const std::exception& e) {
1318              SWIG_exception(SWIG_RuntimeError, e.what());
1319          }
# Line 1307 | Line 1386 | static PyObject *_wrap_objectMap___setit
1386          try {
1387              std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1388              
1389 +        }catch (const BossSchedFailure & e) {
1390 +            SWIG_exception(SWIG_ValueError, e.what());
1391          }catch (const std::exception& e) {
1392              SWIG_exception(SWIG_RuntimeError, e.what());
1393          }
# Line 1369 | Line 1450 | static PyObject *_wrap_objectMap_has_key
1450          try {
1451              result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1452              
1453 +        }catch (const BossSchedFailure & e) {
1454 +            SWIG_exception(SWIG_ValueError, e.what());
1455          }catch (const std::exception& e) {
1456              SWIG_exception(SWIG_RuntimeError, e.what());
1457          }
# Line 1392 | Line 1475 | static PyObject *_wrap_objectMap_keys(Py
1475          try {
1476              result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1477              
1478 +        }catch (const BossSchedFailure & e) {
1479 +            SWIG_exception(SWIG_ValueError, e.what());
1480          }catch (const std::exception& e) {
1481              SWIG_exception(SWIG_RuntimeError, e.what());
1482          }
# Line 1415 | Line 1500 | static PyObject *_wrap_objectMap_values(
1500          try {
1501              result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1502              
1503 +        }catch (const BossSchedFailure & e) {
1504 +            SWIG_exception(SWIG_ValueError, e.what());
1505          }catch (const std::exception& e) {
1506              SWIG_exception(SWIG_RuntimeError, e.what());
1507          }
# Line 1438 | Line 1525 | static PyObject *_wrap_objectMap_items(P
1525          try {
1526              result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1527              
1528 +        }catch (const BossSchedFailure & e) {
1529 +            SWIG_exception(SWIG_ValueError, e.what());
1530          }catch (const std::exception& e) {
1531              SWIG_exception(SWIG_RuntimeError, e.what());
1532          }
# Line 1469 | Line 1558 | static PyObject *_wrap_objectMap___conta
1558          try {
1559              result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1560              
1561 +        }catch (const BossSchedFailure & e) {
1562 +            SWIG_exception(SWIG_ValueError, e.what());
1563          }catch (const std::exception& e) {
1564              SWIG_exception(SWIG_RuntimeError, e.what());
1565          }
# Line 1515 | Line 1606 | static PyObject *_wrap_delete_objectMap(
1606          try {
1607              delete arg1;
1608              
1609 +        }catch (const BossSchedFailure & e) {
1610 +            SWIG_exception(SWIG_ValueError, e.what());
1611          }catch (const std::exception& e) {
1612              SWIG_exception(SWIG_RuntimeError, e.what());
1613          }
# Line 1533 | Line 1626 | static PyObject * objectMap_swigregister
1626      Py_INCREF(obj);
1627      return Py_BuildValue((char *)"");
1628   }
1629 < static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
1629 > static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1630      PyObject *resultobj;
1631 <    BossSession *arg1 = (BossSession *) 0 ;
1632 <    std::vector<std::string > *arg2 = 0 ;
1633 <    PyObject *result;
1631 >    unsigned int arg1 = (unsigned int) 0 ;
1632 >    std::vector<std::string > *result;
1633 >    PyObject * obj0 = 0 ;
1634 >    
1635 >    if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1636 >    if (obj0) {
1637 >        arg1 = (unsigned int) PyInt_AsLong(obj0);
1638 >        if (PyErr_Occurred()) SWIG_fail;
1639 >    }
1640 >    {
1641 >        try {
1642 >            result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1643 >            
1644 >        }catch (const BossSchedFailure & e) {
1645 >            SWIG_exception(SWIG_ValueError, e.what());
1646 >        }catch (const std::exception& e) {
1647 >            SWIG_exception(SWIG_RuntimeError, e.what());
1648 >        }
1649 >    }
1650 >    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1651 >    return resultobj;
1652 >    fail:
1653 >    return NULL;
1654 > }
1655 >
1656 >
1657 > static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1658 >    PyObject *resultobj;
1659 >    unsigned int arg1 ;
1660 >    std::string *arg2 = 0 ;
1661 >    std::vector<std::string > *result;
1662 >    std::string temp2 ;
1663      PyObject * obj0 = 0 ;
1664      PyObject * obj1 = 0 ;
1665      
1666 <    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
1667 <    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1668 <    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1669 <    if (arg2 == NULL) {
1670 <        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
1666 >    if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1667 >    arg1 = (unsigned int) PyInt_AsLong(obj0);
1668 >    if (PyErr_Occurred()) SWIG_fail;
1669 >    {
1670 >        if (PyString_Check(obj1)) {
1671 >            temp2 = std::string(PyString_AsString(obj1));
1672 >            arg2 = &temp2;
1673 >        }else {
1674 >            SWIG_exception(SWIG_TypeError, "string expected");
1675 >        }
1676      }
1677      {
1678          try {
1679 <            result = (PyObject *)BossSession_show(arg1,*arg2);
1679 >            result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1680              
1681 +        }catch (const BossSchedFailure & e) {
1682 +            SWIG_exception(SWIG_ValueError, e.what());
1683          }catch (const std::exception& e) {
1684              SWIG_exception(SWIG_RuntimeError, e.what());
1685          }
1686      }
1687 <    resultobj = result;
1687 >    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1688      return resultobj;
1689      fail:
1690      return NULL;
1691   }
1692  
1693  
1694 < static PyObject *_wrap_BossSession_showCHTools__SWIG_1(PyObject *self, PyObject *args) {
1694 > static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1695      PyObject *resultobj;
1696 <    BossSession *arg1 = (BossSession *) 0 ;
1697 <    PyObject *result;
1696 >    std::vector<std::string > *arg1 = 0 ;
1697 >    std::vector<std::string > *result;
1698 >    std::vector<std::string > temp1 ;
1699 >    std::vector<std::string > *v1 ;
1700      PyObject * obj0 = 0 ;
1701      
1702 <    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
1703 <    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1702 >    if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1703 >    {
1704 >        if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1705 >            unsigned int size = (PyTuple_Check(obj0) ?
1706 >            PyTuple_Size(obj0) :
1707 >            PyList_Size(obj0));
1708 >            temp1 = std::vector<std::string >(size);
1709 >            arg1 = &temp1;
1710 >            for (unsigned int i=0; i<size; i++) {
1711 >                PyObject* o = PySequence_GetItem(obj0,i);
1712 >                if (PyString_Check(o)) {
1713 >                    temp1[i] = (std::string)(\
1714 >                    SwigString_AsString(o));
1715 >                    Py_DECREF(o);
1716 >                }else {
1717 >                    Py_DECREF(o);
1718 >                    PyErr_SetString(PyExc_TypeError,
1719 >                    "vector<""std::string""> expected");
1720 >                    SWIG_fail;
1721 >                }
1722 >            }
1723 >        }else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1724 >        SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1725 >            arg1 = v1;
1726 >        }else {
1727 >            PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1728 >            SWIG_fail;
1729 >        }
1730 >    }
1731      {
1732          try {
1733 <            result = (PyObject *)BossSession_showCHTools__SWIG_1(arg1);
1733 >            result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1734              
1735 +        }catch (const BossSchedFailure & e) {
1736 +            SWIG_exception(SWIG_ValueError, e.what());
1737          }catch (const std::exception& e) {
1738              SWIG_exception(SWIG_RuntimeError, e.what());
1739          }
1740      }
1741 <    resultobj = result;
1741 >    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1742      return resultobj;
1743      fail:
1744      return NULL;
1745   }
1746  
1747  
1748 < static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
1748 > static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1749      int argc;
1750 <    PyObject *argv[2];
1750 >    PyObject *argv[3];
1751      int ii;
1752      
1753      argc = PyObject_Length(args);
1754 <    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1754 >    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1755          argv[ii] = PyTuple_GetItem(args,ii);
1756      }
1757 +    if ((argc >= 0) && (argc <= 1)) {
1758 +        int _v;
1759 +        if (argc <= 0) {
1760 +            return _wrap_new_vector_string__SWIG_0(self,args);
1761 +        }
1762 +        {
1763 +            _v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1764 +        }
1765 +        if (_v) {
1766 +            return _wrap_new_vector_string__SWIG_0(self,args);
1767 +        }
1768 +    }
1769      if (argc == 1) {
1770          int _v;
1771          {
1772 <            void *ptr;
1773 <            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1774 <                _v = 0;
1775 <                PyErr_Clear();
1772 >            /* native sequence? */
1773 >            if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1774 >                unsigned int size = (PyTuple_Check(argv[0]) ?
1775 >                PyTuple_Size(argv[0]) :
1776 >                PyList_Size(argv[0]));
1777 >                if (size == 0) {
1778 >                    /* an empty sequence can be of any type */
1779 >                    _v = 1;
1780 >                }else {
1781 >                    /* check the first element only */
1782 >                    PyObject* o = PySequence_GetItem(argv[0],0);
1783 >                    if (PyString_Check(o))
1784 >                    _v = 1;
1785 >                    else
1786 >                    _v = 0;
1787 >                    Py_DECREF(o);
1788 >                }
1789              }else {
1790 +                /* wrapped vector? */
1791 +                std::vector<std::string >* v;
1792 +                if (SWIG_ConvertPtr(argv[0],(void **) &v,
1793 +                SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1794                  _v = 1;
1795 +                else
1796 +                _v = 0;
1797              }
1798          }
1799          if (_v) {
1800 <            return _wrap_BossSession_showCHTools__SWIG_1(self,args);
1800 >            return _wrap_new_vector_string__SWIG_2(self,args);
1801 >        }
1802 >    }
1803 >    if (argc == 2) {
1804 >        int _v;
1805 >        {
1806 >            _v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1807 >        }
1808 >        if (_v) {
1809 >            {
1810 >                _v = PyString_Check(argv[1]) ? 1 : 0;
1811 >            }
1812 >            if (_v) {
1813 >                return _wrap_new_vector_string__SWIG_1(self,args);
1814 >            }
1815          }
1816      }
1817      
1818 <    PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showCHTools'");
1818 >    PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1819      return NULL;
1820   }
1821  
1822  
1823 < static PyObject *_wrap_BossSession_showProgramTypes__SWIG_1(PyObject *self, PyObject *args) {
1823 > static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1824      PyObject *resultobj;
1825 <    BossSession *arg1 = (BossSession *) 0 ;
1826 <    PyObject *result;
1825 >    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1826 >    unsigned int result;
1827 >    std::vector<std::string > temp1 ;
1828 >    std::vector<std::string > *v1 ;
1829      PyObject * obj0 = 0 ;
1830      
1831 <    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
1832 <    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1831 >    if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1832 >    {
1833 >        if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1834 >            unsigned int size = (PyTuple_Check(obj0) ?
1835 >            PyTuple_Size(obj0) :
1836 >            PyList_Size(obj0));
1837 >            temp1 = std::vector<std::string >(size);
1838 >            arg1 = &temp1;
1839 >            for (unsigned int i=0; i<size; i++) {
1840 >                PyObject* o = PySequence_GetItem(obj0,i);
1841 >                if (PyString_Check(o)) {
1842 >                    temp1[i] = (std::string)(\
1843 >                    SwigString_AsString(o));
1844 >                    Py_DECREF(o);
1845 >                }else {
1846 >                    Py_DECREF(o);
1847 >                    PyErr_SetString(PyExc_TypeError,
1848 >                    "vector<""std::string""> expected");
1849 >                    SWIG_fail;
1850 >                }
1851 >            }
1852 >        }else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1853 >        SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1854 >            arg1 = v1;
1855 >        }else {
1856 >            PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1857 >            SWIG_fail;
1858 >        }
1859 >    }
1860      {
1861          try {
1862 <            result = (PyObject *)BossSession_showProgramTypes__SWIG_1(arg1);
1862 >            result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1863              
1864 +        }catch (const BossSchedFailure & e) {
1865 +            SWIG_exception(SWIG_ValueError, e.what());
1866          }catch (const std::exception& e) {
1867              SWIG_exception(SWIG_RuntimeError, e.what());
1868          }
1869      }
1870 <    resultobj = result;
1870 >    resultobj = PyInt_FromLong((long)result);
1871      return resultobj;
1872      fail:
1873      return NULL;
1874   }
1875  
1876  
1877 < static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
1878 <    int argc;
1879 <    PyObject *argv[2];
1880 <    int ii;
1877 > static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
1878 >    PyObject *resultobj;
1879 >    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1880 >    bool result;
1881 >    std::vector<std::string > temp1 ;
1882 >    std::vector<std::string > *v1 ;
1883 >    PyObject * obj0 = 0 ;
1884      
1885 <    argc = PyObject_Length(args);
1886 <    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1887 <        argv[ii] = PyTuple_GetItem(args,ii);
1885 >    if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
1886 >    {
1887 >        if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1888 >            unsigned int size = (PyTuple_Check(obj0) ?
1889 >            PyTuple_Size(obj0) :
1890 >            PyList_Size(obj0));
1891 >            temp1 = std::vector<std::string >(size);
1892 >            arg1 = &temp1;
1893 >            for (unsigned int i=0; i<size; i++) {
1894 >                PyObject* o = PySequence_GetItem(obj0,i);
1895 >                if (PyString_Check(o)) {
1896 >                    temp1[i] = (std::string)(\
1897 >                    SwigString_AsString(o));
1898 >                    Py_DECREF(o);
1899 >                }else {
1900 >                    Py_DECREF(o);
1901 >                    PyErr_SetString(PyExc_TypeError,
1902 >                    "vector<""std::string""> expected");
1903 >                    SWIG_fail;
1904 >                }
1905 >            }
1906 >        }else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1907 >        SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1908 >            arg1 = v1;
1909 >        }else {
1910 >            PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1911 >            SWIG_fail;
1912 >        }
1913      }
1914 <    if (argc == 1) {
1915 <        int _v;
1916 <        {
1917 <            void *ptr;
1918 <            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1919 <                _v = 0;
1920 <                PyErr_Clear();
1921 <            }else {
1922 <                _v = 1;
1914 >    {
1915 >        try {
1916 >            result = (bool)((std::vector<std::string > const *)arg1)->empty();
1917 >            
1918 >        }catch (const BossSchedFailure & e) {
1919 >            SWIG_exception(SWIG_ValueError, e.what());
1920 >        }catch (const std::exception& e) {
1921 >            SWIG_exception(SWIG_RuntimeError, e.what());
1922 >        }
1923 >    }
1924 >    resultobj = PyInt_FromLong((long)result);
1925 >    return resultobj;
1926 >    fail:
1927 >    return NULL;
1928 > }
1929 >
1930 >
1931 > static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
1932 >    PyObject *resultobj;
1933 >    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1934 >    PyObject * obj0 = 0 ;
1935 >    
1936 >    if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
1937 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1938 >    {
1939 >        try {
1940 >            (arg1)->clear();
1941 >            
1942 >        }catch (const BossSchedFailure & e) {
1943 >            SWIG_exception(SWIG_ValueError, e.what());
1944 >        }catch (const std::exception& e) {
1945 >            SWIG_exception(SWIG_RuntimeError, e.what());
1946 >        }
1947 >    }
1948 >    Py_INCREF(Py_None); resultobj = Py_None;
1949 >    return resultobj;
1950 >    fail:
1951 >    return NULL;
1952 > }
1953 >
1954 >
1955 > static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
1956 >    PyObject *resultobj;
1957 >    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1958 >    std::string arg2 ;
1959 >    PyObject * obj0 = 0 ;
1960 >    PyObject * obj1 = 0 ;
1961 >    
1962 >    if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
1963 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1964 >    {
1965 >        if (PyString_Check(obj1))
1966 >        arg2 = std::string(PyString_AsString(obj1));
1967 >        else
1968 >        SWIG_exception(SWIG_TypeError, "string expected");
1969 >    }
1970 >    {
1971 >        try {
1972 >            (arg1)->push_back(arg2);
1973 >            
1974 >        }catch (const BossSchedFailure & e) {
1975 >            SWIG_exception(SWIG_ValueError, e.what());
1976 >        }catch (const std::exception& e) {
1977 >            SWIG_exception(SWIG_RuntimeError, e.what());
1978 >        }
1979 >    }
1980 >    Py_INCREF(Py_None); resultobj = Py_None;
1981 >    return resultobj;
1982 >    fail:
1983 >    return NULL;
1984 > }
1985 >
1986 >
1987 > static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
1988 >    PyObject *resultobj;
1989 >    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1990 >    std::string result;
1991 >    PyObject * obj0 = 0 ;
1992 >    
1993 >    if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
1994 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1995 >    {
1996 >        try {
1997 >            result = std_vectorlstd_string_g_pop___(arg1);
1998 >            
1999 >        }catch (std::out_of_range& e) {
2000 >            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2001 >        }
2002 >    }
2003 >    {
2004 >        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2005 >    }
2006 >    return resultobj;
2007 >    fail:
2008 >    return NULL;
2009 > }
2010 >
2011 >
2012 > static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
2013 >    PyObject *resultobj;
2014 >    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2015 >    int arg2 ;
2016 >    std::string result;
2017 >    PyObject * obj0 = 0 ;
2018 >    
2019 >    if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
2020 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2021 >    {
2022 >        try {
2023 >            result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
2024 >            
2025 >        }catch (std::out_of_range& e) {
2026 >            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2027 >        }
2028 >    }
2029 >    {
2030 >        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2031 >    }
2032 >    return resultobj;
2033 >    fail:
2034 >    return NULL;
2035 > }
2036 >
2037 >
2038 > static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2039 >    PyObject *resultobj;
2040 >    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2041 >    int arg2 ;
2042 >    int arg3 ;
2043 >    std::vector<std::string > result;
2044 >    PyObject * obj0 = 0 ;
2045 >    
2046 >    if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2047 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2048 >    {
2049 >        try {
2050 >            result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2051 >            
2052 >        }catch (const BossSchedFailure & e) {
2053 >            SWIG_exception(SWIG_ValueError, e.what());
2054 >        }catch (const std::exception& e) {
2055 >            SWIG_exception(SWIG_RuntimeError, e.what());
2056 >        }
2057 >    }
2058 >    {
2059 >        resultobj = PyTuple_New((&result)->size());
2060 >        for (unsigned int i=0; i<(&result)->size(); i++)
2061 >        PyTuple_SetItem(resultobj,i,
2062 >        SwigString_FromString(((std::vector<std::string > &)result)[i]));
2063 >    }
2064 >    return resultobj;
2065 >    fail:
2066 >    return NULL;
2067 > }
2068 >
2069 >
2070 > static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2071 >    PyObject *resultobj;
2072 >    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2073 >    int arg2 ;
2074 >    std::string arg3 ;
2075 >    PyObject * obj0 = 0 ;
2076 >    PyObject * obj2 = 0 ;
2077 >    
2078 >    if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2079 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2080 >    {
2081 >        if (PyString_Check(obj2))
2082 >        arg3 = std::string(PyString_AsString(obj2));
2083 >        else
2084 >        SWIG_exception(SWIG_TypeError, "string expected");
2085 >    }
2086 >    {
2087 >        try {
2088 >            std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2089 >            
2090 >        }catch (std::out_of_range& e) {
2091 >            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2092 >        }
2093 >    }
2094 >    Py_INCREF(Py_None); resultobj = Py_None;
2095 >    return resultobj;
2096 >    fail:
2097 >    return NULL;
2098 > }
2099 >
2100 >
2101 > static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2102 >    PyObject *resultobj;
2103 >    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2104 >    int arg2 ;
2105 >    int arg3 ;
2106 >    std::vector<std::string > *arg4 = 0 ;
2107 >    std::vector<std::string > temp4 ;
2108 >    std::vector<std::string > *v4 ;
2109 >    PyObject * obj0 = 0 ;
2110 >    PyObject * obj3 = 0 ;
2111 >    
2112 >    if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2113 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2114 >    {
2115 >        if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2116 >            unsigned int size = (PyTuple_Check(obj3) ?
2117 >            PyTuple_Size(obj3) :
2118 >            PyList_Size(obj3));
2119 >            temp4 = std::vector<std::string >(size);
2120 >            arg4 = &temp4;
2121 >            for (unsigned int i=0; i<size; i++) {
2122 >                PyObject* o = PySequence_GetItem(obj3,i);
2123 >                if (PyString_Check(o)) {
2124 >                    temp4[i] = (std::string)(\
2125 >                    SwigString_AsString(o));
2126 >                    Py_DECREF(o);
2127 >                }else {
2128 >                    Py_DECREF(o);
2129 >                    PyErr_SetString(PyExc_TypeError,
2130 >                    "vector<""std::string""> expected");
2131 >                    SWIG_fail;
2132 >                }
2133              }
2134 +        }else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2135 +        SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2136 +            arg4 = v4;
2137 +        }else {
2138 +            PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2139 +            SWIG_fail;
2140          }
2141 <        if (_v) {
2142 <            return _wrap_BossSession_showProgramTypes__SWIG_1(self,args);
2141 >    }
2142 >    {
2143 >        try {
2144 >            std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2145 >            
2146 >        }catch (const BossSchedFailure & e) {
2147 >            SWIG_exception(SWIG_ValueError, e.what());
2148 >        }catch (const std::exception& e) {
2149 >            SWIG_exception(SWIG_RuntimeError, e.what());
2150 >        }
2151 >    }
2152 >    Py_INCREF(Py_None); resultobj = Py_None;
2153 >    return resultobj;
2154 >    fail:
2155 >    return NULL;
2156 > }
2157 >
2158 >
2159 > static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2160 >    PyObject *resultobj;
2161 >    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2162 >    int arg2 ;
2163 >    PyObject * obj0 = 0 ;
2164 >    
2165 >    if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2166 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2167 >    {
2168 >        try {
2169 >            std_vectorlstd_string_g___delitem_____(arg1,arg2);
2170 >            
2171 >        }catch (std::out_of_range& e) {
2172 >            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2173          }
2174      }
2175 +    Py_INCREF(Py_None); resultobj = Py_None;
2176 +    return resultobj;
2177 +    fail:
2178 +    return NULL;
2179 + }
2180 +
2181 +
2182 + static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2183 +    PyObject *resultobj;
2184 +    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2185 +    int arg2 ;
2186 +    int arg3 ;
2187 +    PyObject * obj0 = 0 ;
2188      
2189 <    PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showProgramTypes'");
2189 >    if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2190 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2191 >    {
2192 >        try {
2193 >            std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2194 >            
2195 >        }catch (const BossSchedFailure & e) {
2196 >            SWIG_exception(SWIG_ValueError, e.what());
2197 >        }catch (const std::exception& e) {
2198 >            SWIG_exception(SWIG_RuntimeError, e.what());
2199 >        }
2200 >    }
2201 >    Py_INCREF(Py_None); resultobj = Py_None;
2202 >    return resultobj;
2203 >    fail:
2204      return NULL;
2205   }
2206  
2207  
2208 < static PyObject *_wrap_BossSession_showRTMon__SWIG_1(PyObject *self, PyObject *args) {
2208 > static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2209 >    PyObject *resultobj;
2210 >    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2211 >    PyObject * obj0 = 0 ;
2212 >    
2213 >    if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2214 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2215 >    {
2216 >        try {
2217 >            delete arg1;
2218 >            
2219 >        }catch (const BossSchedFailure & e) {
2220 >            SWIG_exception(SWIG_ValueError, e.what());
2221 >        }catch (const std::exception& e) {
2222 >            SWIG_exception(SWIG_RuntimeError, e.what());
2223 >        }
2224 >    }
2225 >    Py_INCREF(Py_None); resultobj = Py_None;
2226 >    return resultobj;
2227 >    fail:
2228 >    return NULL;
2229 > }
2230 >
2231 >
2232 > static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2233 >    PyObject *obj;
2234 >    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2235 >    SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2236 >    Py_INCREF(obj);
2237 >    return Py_BuildValue((char *)"");
2238 > }
2239 > static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
2240      PyObject *resultobj;
2241      BossSession *arg1 = (BossSession *) 0 ;
2242 +    std::vector<std::string > *arg2 = 0 ;
2243      PyObject *result;
2244      PyObject * obj0 = 0 ;
2245 +    PyObject * obj1 = 0 ;
2246      
2247 <    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2247 >    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
2248      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2249 +    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2250 +    if (arg2 == NULL) {
2251 +        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2252 +    }
2253      {
2254          try {
2255 <            result = (PyObject *)BossSession_showRTMon__SWIG_1(arg1);
2255 >            result = (PyObject *)BossSession_show(arg1,*arg2);
2256              
2257 +        }catch (const BossSchedFailure & e) {
2258 +            SWIG_exception(SWIG_ValueError, e.what());
2259          }catch (const std::exception& e) {
2260              SWIG_exception(SWIG_RuntimeError, e.what());
2261          }
# Line 1691 | Line 2267 | static PyObject *_wrap_BossSession_showR
2267   }
2268  
2269  
2270 < static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2271 <    int argc;
2272 <    PyObject *argv[2];
2273 <    int ii;
2270 > static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
2271 >    PyObject *resultobj;
2272 >    BossSession *arg1 = (BossSession *) 0 ;
2273 >    PyObject *result;
2274 >    PyObject * obj0 = 0 ;
2275      
2276 <    argc = PyObject_Length(args);
2277 <    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2278 <        argv[ii] = PyTuple_GetItem(args,ii);
2279 <    }
2280 <    if (argc == 1) {
2281 <        int _v;
2282 <        {
2283 <            void *ptr;
2284 <            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2285 <                _v = 0;
1709 <                PyErr_Clear();
1710 <            }else {
1711 <                _v = 1;
1712 <            }
2276 >    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
2277 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2278 >    {
2279 >        try {
2280 >            result = (PyObject *)BossSession_CHTools(arg1);
2281 >            
2282 >        }catch (const BossSchedFailure & e) {
2283 >            SWIG_exception(SWIG_ValueError, e.what());
2284 >        }catch (const std::exception& e) {
2285 >            SWIG_exception(SWIG_RuntimeError, e.what());
2286          }
2287 <        if (_v) {
2288 <            return _wrap_BossSession_showRTMon__SWIG_1(self,args);
2287 >    }
2288 >    resultobj = result;
2289 >    return resultobj;
2290 >    fail:
2291 >    return NULL;
2292 > }
2293 >
2294 >
2295 > static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
2296 >    PyObject *resultobj;
2297 >    BossSession *arg1 = (BossSession *) 0 ;
2298 >    PyObject *result;
2299 >    PyObject * obj0 = 0 ;
2300 >    
2301 >    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
2302 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2303 >    {
2304 >        try {
2305 >            result = (PyObject *)BossSession_ProgramTypes(arg1);
2306 >            
2307 >        }catch (const BossSchedFailure & e) {
2308 >            SWIG_exception(SWIG_ValueError, e.what());
2309 >        }catch (const std::exception& e) {
2310 >            SWIG_exception(SWIG_RuntimeError, e.what());
2311          }
2312      }
2313 +    resultobj = result;
2314 +    return resultobj;
2315 +    fail:
2316 +    return NULL;
2317 + }
2318 +
2319 +
2320 + static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
2321 +    PyObject *resultobj;
2322 +    BossSession *arg1 = (BossSession *) 0 ;
2323 +    PyObject *result;
2324 +    PyObject * obj0 = 0 ;
2325      
2326 <    PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showRTMon'");
2326 >    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
2327 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2328 >    {
2329 >        try {
2330 >            result = (PyObject *)BossSession_RTMons(arg1);
2331 >            
2332 >        }catch (const BossSchedFailure & e) {
2333 >            SWIG_exception(SWIG_ValueError, e.what());
2334 >        }catch (const std::exception& e) {
2335 >            SWIG_exception(SWIG_RuntimeError, e.what());
2336 >        }
2337 >    }
2338 >    resultobj = result;
2339 >    return resultobj;
2340 >    fail:
2341      return NULL;
2342   }
2343  
2344  
2345 < static PyObject *_wrap_BossSession_showSchedulers__SWIG_1(PyObject *self, PyObject *args) {
2345 > static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
2346      PyObject *resultobj;
2347      BossSession *arg1 = (BossSession *) 0 ;
2348      PyObject *result;
2349      PyObject * obj0 = 0 ;
2350      
2351 <    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2351 >    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
2352      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2353      {
2354          try {
2355 <            result = (PyObject *)BossSession_showSchedulers__SWIG_1(arg1);
2355 >            result = (PyObject *)BossSession_schedulers(arg1);
2356              
2357 +        }catch (const BossSchedFailure & e) {
2358 +            SWIG_exception(SWIG_ValueError, e.what());
2359          }catch (const std::exception& e) {
2360              SWIG_exception(SWIG_RuntimeError, e.what());
2361          }
# Line 1744 | Line 2367 | static PyObject *_wrap_BossSession_showS
2367   }
2368  
2369  
2370 < static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2371 <    int argc;
2372 <    PyObject *argv[2];
2373 <    int ii;
2370 > static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
2371 >    PyObject *resultobj;
2372 >    BossSession *arg1 = (BossSession *) 0 ;
2373 >    std::string *arg2 = 0 ;
2374 >    std::string *arg3 = 0 ;
2375 >    std::string const &arg4_defvalue = "" ;
2376 >    std::string *arg4 = (std::string *) &arg4_defvalue ;
2377 >    std::string const &arg5_defvalue = "" ;
2378 >    std::string *arg5 = (std::string *) &arg5_defvalue ;
2379 >    bool arg6 = (bool) false ;
2380 >    PyObject *result;
2381 >    std::string temp2 ;
2382 >    std::string temp3 ;
2383 >    std::string temp4 ;
2384 >    std::string temp5 ;
2385 >    PyObject * obj0 = 0 ;
2386 >    PyObject * obj1 = 0 ;
2387 >    PyObject * obj2 = 0 ;
2388 >    PyObject * obj3 = 0 ;
2389 >    PyObject * obj4 = 0 ;
2390 >    PyObject * obj5 = 0 ;
2391      
2392 <    argc = PyObject_Length(args);
2393 <    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2394 <        argv[ii] = PyTuple_GetItem(args,ii);
2392 >    if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2393 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2394 >    {
2395 >        if (PyString_Check(obj1)) {
2396 >            temp2 = std::string(PyString_AsString(obj1));
2397 >            arg2 = &temp2;
2398 >        }else {
2399 >            SWIG_exception(SWIG_TypeError, "string expected");
2400 >        }
2401      }
2402 <    if (argc == 1) {
2403 <        int _v;
2402 >    {
2403 >        if (PyString_Check(obj2)) {
2404 >            temp3 = std::string(PyString_AsString(obj2));
2405 >            arg3 = &temp3;
2406 >        }else {
2407 >            SWIG_exception(SWIG_TypeError, "string expected");
2408 >        }
2409 >    }
2410 >    if (obj3) {
2411          {
2412 <            void *ptr;
2413 <            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2414 <                _v = 0;
1762 <                PyErr_Clear();
2412 >            if (PyString_Check(obj3)) {
2413 >                temp4 = std::string(PyString_AsString(obj3));
2414 >                arg4 = &temp4;
2415              }else {
2416 <                _v = 1;
2416 >                SWIG_exception(SWIG_TypeError, "string expected");
2417              }
2418          }
2419 <        if (_v) {
2420 <            return _wrap_BossSession_showSchedulers__SWIG_1(self,args);
2419 >    }
2420 >    if (obj4) {
2421 >        {
2422 >            if (PyString_Check(obj4)) {
2423 >                temp5 = std::string(PyString_AsString(obj4));
2424 >                arg5 = &temp5;
2425 >            }else {
2426 >                SWIG_exception(SWIG_TypeError, "string expected");
2427 >            }
2428          }
2429      }
2430 <    
2431 <    PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showSchedulers'");
2430 >    if (obj5) {
2431 >        arg6 = PyInt_AsLong(obj5) ? true : false;
2432 >        if (PyErr_Occurred()) SWIG_fail;
2433 >    }
2434 >    {
2435 >        try {
2436 >            result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
2437 >            
2438 >        }catch (const BossSchedFailure & e) {
2439 >            SWIG_exception(SWIG_ValueError, e.what());
2440 >        }catch (const std::exception& e) {
2441 >            SWIG_exception(SWIG_RuntimeError, e.what());
2442 >        }
2443 >    }
2444 >    resultobj = result;
2445 >    return resultobj;
2446 >    fail:
2447      return NULL;
2448   }
2449  
# Line 1875 | Line 2549 | static PyObject *_wrap_BossSession_query
2549          try {
2550              result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2551              
2552 +        }catch (const BossSchedFailure & e) {
2553 +            SWIG_exception(SWIG_ValueError, e.what());
2554          }catch (const std::exception& e) {
2555              SWIG_exception(SWIG_RuntimeError, e.what());
2556          }
# Line 1889 | Line 2565 | static PyObject *_wrap_BossSession_query
2565   static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2566      PyObject *resultobj;
2567      std::string arg1 = (std::string) "" ;
2568 +    std::string arg2 = (std::string) "2" ;
2569 +    std::string arg3 = (std::string) "" ;
2570      BossSession *result;
2571      PyObject * obj0 = 0 ;
2572 +    PyObject * obj1 = 0 ;
2573 +    PyObject * obj2 = 0 ;
2574      
2575 <    if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2575 >    if(!PyArg_ParseTuple(args,(char *)"|OOO:new_BossSession",&obj0,&obj1,&obj2)) goto fail;
2576      if (obj0) {
2577          {
2578              if (PyString_Check(obj0))
# Line 1901 | Line 2581 | static PyObject *_wrap_new_BossSession(P
2581              SWIG_exception(SWIG_TypeError, "string expected");
2582          }
2583      }
2584 +    if (obj1) {
2585 +        {
2586 +            if (PyString_Check(obj1))
2587 +            arg2 = std::string(PyString_AsString(obj1));
2588 +            else
2589 +            SWIG_exception(SWIG_TypeError, "string expected");
2590 +        }
2591 +    }
2592 +    if (obj2) {
2593 +        {
2594 +            if (PyString_Check(obj2))
2595 +            arg3 = std::string(PyString_AsString(obj2));
2596 +            else
2597 +            SWIG_exception(SWIG_TypeError, "string expected");
2598 +        }
2599 +    }
2600      {
2601          try {
2602 <            result = (BossSession *)new BossSession(arg1);
2602 >            result = (BossSession *)new BossSession(arg1,arg2,arg3);
2603              
2604 +        }catch (const BossSchedFailure & e) {
2605 +            SWIG_exception(SWIG_ValueError, e.what());
2606          }catch (const std::exception& e) {
2607              SWIG_exception(SWIG_RuntimeError, e.what());
2608          }
# Line 1927 | Line 2625 | static PyObject *_wrap_delete_BossSessio
2625          try {
2626              delete arg1;
2627              
2628 +        }catch (const BossSchedFailure & e) {
2629 +            SWIG_exception(SWIG_ValueError, e.what());
2630          }catch (const std::exception& e) {
2631              SWIG_exception(SWIG_RuntimeError, e.what());
2632          }
# Line 1938 | Line 2638 | static PyObject *_wrap_delete_BossSessio
2638   }
2639  
2640  
2641 < static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2641 > static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2642      PyObject *resultobj;
2643      BossSession *arg1 = (BossSession *) 0 ;
1944 –    std::string const &arg2_defvalue = "" ;
1945 –    std::string *arg2 = (std::string *) &arg2_defvalue ;
1946 –    BossTask *result;
1947 –    std::string temp2 ;
2644      PyObject * obj0 = 0 ;
1949 –    PyObject * obj1 = 0 ;
2645      
2646 <    if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2646 >    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2647      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1953 –    if (obj1) {
1954 –        {
1955 –            if (PyString_Check(obj1)) {
1956 –                temp2 = std::string(PyString_AsString(obj1));
1957 –                arg2 = &temp2;
1958 –            }else {
1959 –                SWIG_exception(SWIG_TypeError, "string expected");
1960 –            }
1961 –        }
1962 –    }
2648      {
2649          try {
2650 <            result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
1966 <            
1967 <        }catch (const std::exception& e) {
1968 <            SWIG_exception(SWIG_RuntimeError, e.what());
1969 <        }
1970 <    }
1971 <    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
1972 <    return resultobj;
1973 <    fail:
1974 <    return NULL;
1975 < }
1976 <
1977 <
1978 < static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
1979 <    PyObject *resultobj;
1980 <    BossSession *arg1 = (BossSession *) 0 ;
1981 <    BossTask *arg2 = (BossTask *) 0 ;
1982 <    PyObject * obj0 = 0 ;
1983 <    PyObject * obj1 = 0 ;
1984 <    
1985 <    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
1986 <    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1987 <    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1988 <    {
1989 <        try {
1990 <            (arg1)->destroyBossTask(arg2);
2650 >            (arg1)->resetDB();
2651              
2652 +        }catch (const BossSchedFailure & e) {
2653 +            SWIG_exception(SWIG_ValueError, e.what());
2654          }catch (const std::exception& e) {
2655              SWIG_exception(SWIG_RuntimeError, e.what());
2656          }
# Line 2000 | Line 2662 | static PyObject *_wrap_BossSession_destr
2662   }
2663  
2664  
2665 < static PyObject *_wrap_BossSession_showCHTools__SWIG_0(PyObject *self, PyObject *args) {
2665 > static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2666      PyObject *resultobj;
2667      BossSession *arg1 = (BossSession *) 0 ;
2006 –    SwigValueWrapper< std::vector<std::string > > result;
2668      PyObject * obj0 = 0 ;
2669      
2670 <    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2670 >    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2671      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2672      {
2673          try {
2674 <            result = (arg1)->showCHTools();
2674 >            (arg1)->clear();
2675              
2676 +        }catch (const BossSchedFailure & e) {
2677 +            SWIG_exception(SWIG_ValueError, e.what());
2678          }catch (const std::exception& e) {
2679              SWIG_exception(SWIG_RuntimeError, e.what());
2680          }
2681      }
2682 <    {
2020 <        std::vector<std::string > * resultptr;
2021 <        resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2022 <        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2023 <    }
2682 >    Py_INCREF(Py_None); resultobj = Py_None;
2683      return resultobj;
2684      fail:
2685      return NULL;
2686   }
2687  
2688  
2689 < static PyObject *_wrap_BossSession_showProgramTypes__SWIG_0(PyObject *self, PyObject *args) {
2689 > static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2690      PyObject *resultobj;
2691      BossSession *arg1 = (BossSession *) 0 ;
2692 <    SwigValueWrapper< std::vector<std::string > > result;
2692 >    std::string const &arg2_defvalue = "" ;
2693 >    std::string *arg2 = (std::string *) &arg2_defvalue ;
2694 >    BossTask *result;
2695 >    std::string temp2 ;
2696      PyObject * obj0 = 0 ;
2697 +    PyObject * obj1 = 0 ;
2698      
2699 <    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2699 >    if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2700      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2701 <    {
2702 <        try {
2703 <            result = (arg1)->showProgramTypes();
2704 <            
2705 <        }catch (const std::exception& e) {
2706 <            SWIG_exception(SWIG_RuntimeError, e.what());
2701 >    if (obj1) {
2702 >        {
2703 >            if (PyString_Check(obj1)) {
2704 >                temp2 = std::string(PyString_AsString(obj1));
2705 >                arg2 = &temp2;
2706 >            }else {
2707 >                SWIG_exception(SWIG_TypeError, "string expected");
2708 >            }
2709          }
2710      }
2711      {
2047 –        std::vector<std::string > * resultptr;
2048 –        resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2049 –        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2050 –    }
2051 –    return resultobj;
2052 –    fail:
2053 –    return NULL;
2054 – }
2055 –
2056 –
2057 – static PyObject *_wrap_BossSession_showRTMon__SWIG_0(PyObject *self, PyObject *args) {
2058 –    PyObject *resultobj;
2059 –    BossSession *arg1 = (BossSession *) 0 ;
2060 –    SwigValueWrapper< std::vector<std::string > > result;
2061 –    PyObject * obj0 = 0 ;
2062 –    
2063 –    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2064 –    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2065 –    {
2712          try {
2713 <            result = (arg1)->showRTMon();
2713 >            result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2714              
2715 +        }catch (const BossSchedFailure & e) {
2716 +            SWIG_exception(SWIG_ValueError, e.what());
2717          }catch (const std::exception& e) {
2718              SWIG_exception(SWIG_RuntimeError, e.what());
2719          }
2720      }
2721 <    {
2074 <        std::vector<std::string > * resultptr;
2075 <        resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2076 <        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2077 <    }
2721 >    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2722      return resultobj;
2723      fail:
2724      return NULL;
2725   }
2726  
2727  
2728 < static PyObject *_wrap_BossSession_showSchedulers__SWIG_0(PyObject *self, PyObject *args) {
2728 > static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2729      PyObject *resultobj;
2730      BossSession *arg1 = (BossSession *) 0 ;
2731 <    SwigValueWrapper< std::vector<std::string > > result;
2731 >    BossTask *arg2 = (BossTask *) 0 ;
2732      PyObject * obj0 = 0 ;
2733 +    PyObject * obj1 = 0 ;
2734      
2735 <    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2735 >    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2736      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2737 +    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2738      {
2739          try {
2740 <            result = (arg1)->showSchedulers();
2740 >            (arg1)->destroyBossTask(arg2);
2741              
2742 +        }catch (const BossSchedFailure & e) {
2743 +            SWIG_exception(SWIG_ValueError, e.what());
2744          }catch (const std::exception& e) {
2745              SWIG_exception(SWIG_RuntimeError, e.what());
2746          }
2747      }
2748 <    {
2101 <        std::vector<std::string > * resultptr;
2102 <        resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2103 <        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2104 <    }
2748 >    Py_INCREF(Py_None); resultobj = Py_None;
2749      return resultobj;
2750      fail:
2751      return NULL;
# Line 2120 | Line 2764 | static PyObject *_wrap_BossSession_defau
2764          try {
2765              result = (arg1)->defaultCHTool();
2766              
2767 +        }catch (const BossSchedFailure & e) {
2768 +            SWIG_exception(SWIG_ValueError, e.what());
2769          }catch (const std::exception& e) {
2770              SWIG_exception(SWIG_RuntimeError, e.what());
2771          }
# Line 2145 | Line 2791 | static PyObject *_wrap_BossSession_defau
2791          try {
2792              result = (arg1)->defaultProgramType();
2793              
2794 +        }catch (const BossSchedFailure & e) {
2795 +            SWIG_exception(SWIG_ValueError, e.what());
2796          }catch (const std::exception& e) {
2797              SWIG_exception(SWIG_RuntimeError, e.what());
2798          }
# Line 2170 | Line 2818 | static PyObject *_wrap_BossSession_defau
2818          try {
2819              result = (arg1)->defaultRTMon();
2820              
2821 +        }catch (const BossSchedFailure & e) {
2822 +            SWIG_exception(SWIG_ValueError, e.what());
2823          }catch (const std::exception& e) {
2824              SWIG_exception(SWIG_RuntimeError, e.what());
2825          }
# Line 2195 | Line 2845 | static PyObject *_wrap_BossSession_defau
2845          try {
2846              result = (arg1)->defaultScheduler();
2847              
2848 +        }catch (const BossSchedFailure & e) {
2849 +            SWIG_exception(SWIG_ValueError, e.what());
2850          }catch (const std::exception& e) {
2851              SWIG_exception(SWIG_RuntimeError, e.what());
2852          }
# Line 2220 | Line 2872 | static PyObject *_wrap_BossSession_versi
2872          try {
2873              result = (arg1)->version();
2874              
2875 +        }catch (const BossSchedFailure & e) {
2876 +            SWIG_exception(SWIG_ValueError, e.what());
2877          }catch (const std::exception& e) {
2878              SWIG_exception(SWIG_RuntimeError, e.what());
2879          }
# Line 2245 | Line 2899 | static PyObject *_wrap_BossSession_clien
2899          try {
2900              result = (arg1)->clientID();
2901              
2902 +        }catch (const BossSchedFailure & e) {
2903 +            SWIG_exception(SWIG_ValueError, e.what());
2904          }catch (const std::exception& e) {
2905              SWIG_exception(SWIG_RuntimeError, e.what());
2906          }
# Line 2276 | Line 2932 | static PyObject *_wrap_BossSession_showC
2932          try {
2933              result = (int)(arg1)->showConfigs(arg2);
2934              
2935 <        }catch (const std::exception& e) {
2936 <            SWIG_exception(SWIG_RuntimeError, e.what());
2281 <        }
2282 <    }
2283 <    resultobj = PyInt_FromLong((long)result);
2284 <    return resultobj;
2285 <    fail:
2286 <    return NULL;
2287 < }
2288 <
2289 <
2290 < static PyObject *_wrap_BossSession_purgeTasks(PyObject *self, PyObject *args) {
2291 <    PyObject *resultobj;
2292 <    BossSession *arg1 = (BossSession *) 0 ;
2293 <    std::string *arg2 = 0 ;
2294 <    std::string *arg3 = 0 ;
2295 <    std::string *arg4 = 0 ;
2296 <    std::string const &arg5_defvalue = "0" ;
2297 <    std::string *arg5 = (std::string *) &arg5_defvalue ;
2298 <    int result;
2299 <    std::string temp2 ;
2300 <    std::string temp3 ;
2301 <    std::string temp4 ;
2302 <    std::string temp5 ;
2303 <    PyObject * obj0 = 0 ;
2304 <    PyObject * obj1 = 0 ;
2305 <    PyObject * obj2 = 0 ;
2306 <    PyObject * obj3 = 0 ;
2307 <    PyObject * obj4 = 0 ;
2308 <    
2309 <    if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossSession_purgeTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
2310 <    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2311 <    {
2312 <        if (PyString_Check(obj1)) {
2313 <            temp2 = std::string(PyString_AsString(obj1));
2314 <            arg2 = &temp2;
2315 <        }else {
2316 <            SWIG_exception(SWIG_TypeError, "string expected");
2317 <        }
2318 <    }
2319 <    {
2320 <        if (PyString_Check(obj2)) {
2321 <            temp3 = std::string(PyString_AsString(obj2));
2322 <            arg3 = &temp3;
2323 <        }else {
2324 <            SWIG_exception(SWIG_TypeError, "string expected");
2325 <        }
2326 <    }
2327 <    {
2328 <        if (PyString_Check(obj3)) {
2329 <            temp4 = std::string(PyString_AsString(obj3));
2330 <            arg4 = &temp4;
2331 <        }else {
2332 <            SWIG_exception(SWIG_TypeError, "string expected");
2333 <        }
2334 <    }
2335 <    if (obj4) {
2336 <        {
2337 <            if (PyString_Check(obj4)) {
2338 <                temp5 = std::string(PyString_AsString(obj4));
2339 <                arg5 = &temp5;
2340 <            }else {
2341 <                SWIG_exception(SWIG_TypeError, "string expected");
2342 <            }
2343 <        }
2344 <    }
2345 <    {
2346 <        try {
2347 <            result = (int)(arg1)->purgeTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
2348 <            
2935 >        }catch (const BossSchedFailure & e) {
2936 >            SWIG_exception(SWIG_ValueError, e.what());
2937          }catch (const std::exception& e) {
2938              SWIG_exception(SWIG_RuntimeError, e.what());
2939          }
# Line 2399 | Line 2987 | static PyObject *_wrap_BossSession_RTupd
2987          try {
2988              result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2989              
2990 +        }catch (const BossSchedFailure & e) {
2991 +            SWIG_exception(SWIG_ValueError, e.what());
2992          }catch (const std::exception& e) {
2993              SWIG_exception(SWIG_RuntimeError, e.what());
2994          }
# Line 2420 | Line 3010 | static PyObject *_wrap_BossSession_listM
3010      std::string *arg5 = (std::string *) &arg5_defvalue ;
3011      std::string const &arg6_defvalue = "" ;
3012      std::string *arg6 = (std::string *) &arg6_defvalue ;
3013 <    std::string result;
3013 >    std::vector<std::string > result;
3014      std::string temp2 ;
3015      std::string temp3 ;
3016      std::string temp5 ;
# Line 2478 | Line 3068 | static PyObject *_wrap_BossSession_listM
3068          try {
3069              result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
3070              
3071 +        }catch (const BossSchedFailure & e) {
3072 +            SWIG_exception(SWIG_ValueError, e.what());
3073          }catch (const std::exception& e) {
3074              SWIG_exception(SWIG_RuntimeError, e.what());
3075          }
3076      }
3077      {
3078 <        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3078 >        resultobj = PyTuple_New((&result)->size());
3079 >        for (unsigned int i=0; i<(&result)->size(); i++)
3080 >        PyTuple_SetItem(resultobj,i,
3081 >        SwigString_FromString(((std::vector<std::string > &)result)[i]));
3082      }
3083      return resultobj;
3084      fail:
# Line 2491 | Line 3086 | static PyObject *_wrap_BossSession_listM
3086   }
3087  
3088  
3089 < static PyObject *_wrap_BossSession_jobQuery(PyObject *self, PyObject *args) {
3089 > static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3090      PyObject *resultobj;
3091      BossSession *arg1 = (BossSession *) 0 ;
3092      int arg2 = (int) SCHEDULED ;
# Line 2505 | Line 3100 | static PyObject *_wrap_BossSession_jobQu
3100      std::string arg7 = (std::string) "" ;
3101      std::string arg8 = (std::string) "" ;
3102      std::string arg9 = (std::string) "" ;
2508 –    bool arg10 = (bool) false ;
2509 –    SwigValueWrapper< std::vector<BossJob * > > result;
3103      std::string temp3 ;
3104      std::string temp4 ;
3105      std::string temp5 ;
# Line 2518 | Line 3111 | static PyObject *_wrap_BossSession_jobQu
3111      PyObject * obj6 = 0 ;
3112      PyObject * obj7 = 0 ;
3113      PyObject * obj8 = 0 ;
2521 –    PyObject * obj9 = 0 ;
3114      
3115 <    if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_jobQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3115 >    if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3116      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3117      if (obj2) {
3118          {
# Line 2584 | Line 3176 | static PyObject *_wrap_BossSession_jobQu
3176              SWIG_exception(SWIG_TypeError, "string expected");
3177          }
3178      }
2587 –    if (obj9) {
2588 –        arg10 = PyInt_AsLong(obj9) ? true : false;
2589 –        if (PyErr_Occurred()) SWIG_fail;
2590 –    }
3179      {
3180          try {
3181 <            result = (arg1)->jobQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3181 >            (arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3182              
3183 +        }catch (const BossSchedFailure & e) {
3184 +            SWIG_exception(SWIG_ValueError, e.what());
3185          }catch (const std::exception& e) {
3186              SWIG_exception(SWIG_RuntimeError, e.what());
3187          }
3188      }
3189 <    {
2600 <        std::vector<BossJob * > * resultptr;
2601 <        resultptr = new std::vector<BossJob * >((std::vector<BossJob * > &) result);
2602 <        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossJob_p_t, 1);
2603 <    }
3189 >    Py_INCREF(Py_None); resultobj = Py_None;
3190      return resultobj;
3191      fail:
3192      return NULL;
3193   }
3194  
3195  
3196 < static PyObject *_wrap_BossSession_queryPrint(PyObject *self, PyObject *args) {
3196 > static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3197      PyObject *resultobj;
3198      BossSession *arg1 = (BossSession *) 0 ;
3199 <    SwigValueWrapper< std::vector<BossJob * > > arg2 ;
3200 <    std::ostream &arg3_defvalue = std::cout ;
3201 <    std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
3202 <    jobStates const &arg4_defvalue = SCHEDULED ;
3203 <    jobStates *arg4 = (jobStates *) &arg4_defvalue ;
3204 <    printOption const &arg5_defvalue = NORMAL ;
3205 <    printOption *arg5 = (printOption *) &arg5_defvalue ;
3206 <    std::string const &arg6_defvalue = "" ;
3207 <    std::string *arg6 = (std::string *) &arg6_defvalue ;
3208 <    std::vector<BossJob * > *argp2 ;
3209 <    std::string temp6 ;
3199 >    std::string const &arg2_defvalue = "all" ;
3200 >    std::string *arg2 = (std::string *) &arg2_defvalue ;
3201 >    std::string const &arg3_defvalue = "" ;
3202 >    std::string *arg3 = (std::string *) &arg3_defvalue ;
3203 >    std::string const &arg4_defvalue = "" ;
3204 >    std::string *arg4 = (std::string *) &arg4_defvalue ;
3205 >    std::string const &arg5_defvalue = "" ;
3206 >    std::string *arg5 = (std::string *) &arg5_defvalue ;
3207 >    std::vector<std::string > result;
3208 >    std::string temp2 ;
3209 >    std::string temp3 ;
3210 >    std::string temp4 ;
3211 >    std::string temp5 ;
3212      PyObject * obj0 = 0 ;
3213      PyObject * obj1 = 0 ;
3214      PyObject * obj2 = 0 ;
3215      PyObject * obj3 = 0 ;
3216      PyObject * obj4 = 0 ;
2629 –    PyObject * obj5 = 0 ;
3217      
3218 <    if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossSession_queryPrint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3218 >    if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3219      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3220 <    if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3221 <    arg2 = *argp2;
3220 >    if (obj1) {
3221 >        {
3222 >            if (PyString_Check(obj1)) {
3223 >                temp2 = std::string(PyString_AsString(obj1));
3224 >                arg2 = &temp2;
3225 >            }else {
3226 >                SWIG_exception(SWIG_TypeError, "string expected");
3227 >            }
3228 >        }
3229 >    }
3230      if (obj2) {
3231 <        if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3232 <        if (arg3 == NULL) {
3233 <            PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3231 >        {
3232 >            if (PyString_Check(obj2)) {
3233 >                temp3 = std::string(PyString_AsString(obj2));
3234 >                arg3 = &temp3;
3235 >            }else {
3236 >                SWIG_exception(SWIG_TypeError, "string expected");
3237 >            }
3238          }
3239      }
3240      if (obj3) {
3241 <        if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3242 <        if (arg4 == NULL) {
3243 <            PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3241 >        {
3242 >            if (PyString_Check(obj3)) {
3243 >                temp4 = std::string(PyString_AsString(obj3));
3244 >                arg4 = &temp4;
3245 >            }else {
3246 >                SWIG_exception(SWIG_TypeError, "string expected");
3247 >            }
3248          }
3249      }
3250      if (obj4) {
2648 –        if ((SWIG_ConvertPtr(obj4,(void **) &arg5, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2649 –        if (arg5 == NULL) {
2650 –            PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2651 –        }
2652 –    }
2653 –    if (obj5) {
3251          {
3252 <            if (PyString_Check(obj5)) {
3253 <                temp6 = std::string(PyString_AsString(obj5));
3254 <                arg6 = &temp6;
3252 >            if (PyString_Check(obj4)) {
3253 >                temp5 = std::string(PyString_AsString(obj4));
3254 >                arg5 = &temp5;
3255              }else {
3256                  SWIG_exception(SWIG_TypeError, "string expected");
3257              }
# Line 2662 | Line 3259 | static PyObject *_wrap_BossSession_query
3259      }
3260      {
3261          try {
3262 <            (arg1)->queryPrint(arg2,*arg3,(jobStates const &)*arg4,(printOption const &)*arg5,(std::string const &)*arg6);
3262 >            result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3263              
3264 +        }catch (const BossSchedFailure & e) {
3265 +            SWIG_exception(SWIG_ValueError, e.what());
3266          }catch (const std::exception& e) {
3267              SWIG_exception(SWIG_RuntimeError, e.what());
3268          }
3269      }
3270 <    Py_INCREF(Py_None); resultobj = Py_None;
3270 >    {
3271 >        resultobj = PyTuple_New((&result)->size());
3272 >        for (unsigned int i=0; i<(&result)->size(); i++)
3273 >        PyTuple_SetItem(resultobj,i,
3274 >        SwigString_FromString(((std::vector<std::string > &)result)[i]));
3275 >    }
3276      return resultobj;
3277      fail:
3278      return NULL;
3279   }
3280  
3281  
3282 < static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3282 > static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3283      PyObject *resultobj;
3284      BossSession *arg1 = (BossSession *) 0 ;
3285 <    std::string const &arg2_defvalue = "all" ;
3286 <    std::string *arg2 = (std::string *) &arg2_defvalue ;
2683 <    std::string const &arg3_defvalue = "" ;
3285 >    int arg2 = (int) SCHEDULED ;
3286 >    std::string const &arg3_defvalue = "all" ;
3287      std::string *arg3 = (std::string *) &arg3_defvalue ;
3288 <    std::string const &arg4_defvalue = "" ;
3288 >    std::string const &arg4_defvalue = "all" ;
3289      std::string *arg4 = (std::string *) &arg4_defvalue ;
3290      std::string const &arg5_defvalue = "" ;
3291      std::string *arg5 = (std::string *) &arg5_defvalue ;
3292 <    SwigValueWrapper< std::vector<std::string > > result;
3293 <    std::string temp2 ;
3292 >    std::string arg6 = (std::string) "" ;
3293 >    std::string arg7 = (std::string) "" ;
3294 >    std::string arg8 = (std::string) "" ;
3295 >    std::string arg9 = (std::string) "" ;
3296 >    bool arg10 = (bool) false ;
3297 >    SwigValueWrapper< std::vector<BossTask * > > result;
3298      std::string temp3 ;
3299      std::string temp4 ;
3300      std::string temp5 ;
3301      PyObject * obj0 = 0 ;
2695 –    PyObject * obj1 = 0 ;
3302      PyObject * obj2 = 0 ;
3303      PyObject * obj3 = 0 ;
3304      PyObject * obj4 = 0 ;
3305 +    PyObject * obj5 = 0 ;
3306 +    PyObject * obj6 = 0 ;
3307 +    PyObject * obj7 = 0 ;
3308 +    PyObject * obj8 = 0 ;
3309 +    PyObject * obj9 = 0 ;
3310      
3311 <    if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3311 >    if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3312      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2702 –    if (obj1) {
2703 –        {
2704 –            if (PyString_Check(obj1)) {
2705 –                temp2 = std::string(PyString_AsString(obj1));
2706 –                arg2 = &temp2;
2707 –            }else {
2708 –                SWIG_exception(SWIG_TypeError, "string expected");
2709 –            }
2710 –        }
2711 –    }
3313      if (obj2) {
3314          {
3315              if (PyString_Check(obj2)) {
# Line 2739 | Line 3340 | static PyObject *_wrap_BossSession_selec
3340              }
3341          }
3342      }
3343 +    if (obj5) {
3344 +        {
3345 +            if (PyString_Check(obj5))
3346 +            arg6 = std::string(PyString_AsString(obj5));
3347 +            else
3348 +            SWIG_exception(SWIG_TypeError, "string expected");
3349 +        }
3350 +    }
3351 +    if (obj6) {
3352 +        {
3353 +            if (PyString_Check(obj6))
3354 +            arg7 = std::string(PyString_AsString(obj6));
3355 +            else
3356 +            SWIG_exception(SWIG_TypeError, "string expected");
3357 +        }
3358 +    }
3359 +    if (obj7) {
3360 +        {
3361 +            if (PyString_Check(obj7))
3362 +            arg8 = std::string(PyString_AsString(obj7));
3363 +            else
3364 +            SWIG_exception(SWIG_TypeError, "string expected");
3365 +        }
3366 +    }
3367 +    if (obj8) {
3368 +        {
3369 +            if (PyString_Check(obj8))
3370 +            arg9 = std::string(PyString_AsString(obj8));
3371 +            else
3372 +            SWIG_exception(SWIG_TypeError, "string expected");
3373 +        }
3374 +    }
3375 +    if (obj9) {
3376 +        arg10 = PyInt_AsLong(obj9) ? true : false;
3377 +        if (PyErr_Occurred()) SWIG_fail;
3378 +    }
3379      {
3380          try {
3381 <            result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3381 >            result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3382              
3383 +        }catch (const BossSchedFailure & e) {
3384 +            SWIG_exception(SWIG_ValueError, e.what());
3385          }catch (const std::exception& e) {
3386              SWIG_exception(SWIG_RuntimeError, e.what());
3387          }
3388      }
3389      {
3390 <        std::vector<std::string > * resultptr;
3391 <        resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
3392 <        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
3390 >        std::vector<BossTask * > * resultptr;
3391 >        resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3392 >        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3393      }
3394      return resultobj;
3395      fail:
# Line 2815 | Line 3454 | static PyObject *_wrap_new_BossTaskExcep
3454          try {
3455              result = (BossTaskException *)new BossTaskException((char const *)arg1);
3456              
3457 +        }catch (const BossSchedFailure & e) {
3458 +            SWIG_exception(SWIG_ValueError, e.what());
3459          }catch (const std::exception& e) {
3460              SWIG_exception(SWIG_RuntimeError, e.what());
3461          }
# Line 2838 | Line 3479 | static PyObject *_wrap_BossTaskException
3479          try {
3480              result = (char *)((BossTaskException const *)arg1)->what();
3481              
3482 +        }catch (const BossSchedFailure & e) {
3483 +            SWIG_exception(SWIG_ValueError, e.what());
3484          }catch (const std::exception& e) {
3485              SWIG_exception(SWIG_RuntimeError, e.what());
3486          }
# Line 2860 | Line 3503 | static PyObject *_wrap_delete_BossTaskEx
3503          try {
3504              delete arg1;
3505              
3506 +        }catch (const BossSchedFailure & e) {
3507 +            SWIG_exception(SWIG_ValueError, e.what());
3508          }catch (const std::exception& e) {
3509              SWIG_exception(SWIG_RuntimeError, e.what());
3510          }
# Line 2899 | Line 3544 | static PyObject *_wrap_BossTask_appendTo
3544          try {
3545              result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3546              
3547 +        }catch (const BossSchedFailure & e) {
3548 +            SWIG_exception(SWIG_ValueError, e.what());
3549          }catch (const std::exception& e) {
3550              SWIG_exception(SWIG_RuntimeError, e.what());
3551          }
# Line 2928 | Line 3575 | static PyObject *_wrap_BossTask_jobDict(
3575          try {
3576              result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3577              
3578 +        }catch (const BossSchedFailure & e) {
3579 +            SWIG_exception(SWIG_ValueError, e.what());
3580          }catch (const std::exception& e) {
3581              SWIG_exception(SWIG_RuntimeError, e.what());
3582          }
# Line 2939 | Line 3588 | static PyObject *_wrap_BossTask_jobDict(
3588   }
3589  
3590  
3591 < static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3591 > static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
3592      PyObject *resultobj;
3593      BossTask *arg1 = (BossTask *) 0 ;
3594      PyObject *result;
3595      PyObject * obj0 = 0 ;
3596      
3597 <    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3597 >    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
3598      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3599      {
3600          try {
3601 <            result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3601 >            result = (PyObject *)BossTask_jobsDict(arg1);
3602              
3603 +        }catch (const BossSchedFailure & e) {
3604 +            SWIG_exception(SWIG_ValueError, e.what());
3605          }catch (const std::exception& e) {
3606              SWIG_exception(SWIG_RuntimeError, e.what());
3607          }
# Line 2962 | Line 3613 | static PyObject *_wrap_BossTask_jobsMap_
3613   }
3614  
3615  
2965 – static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
2966 –    int argc;
2967 –    PyObject *argv[2];
2968 –    int ii;
2969 –    
2970 –    argc = PyObject_Length(args);
2971 –    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2972 –        argv[ii] = PyTuple_GetItem(args,ii);
2973 –    }
2974 –    if (argc == 1) {
2975 –        int _v;
2976 –        {
2977 –            void *ptr;
2978 –            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
2979 –                _v = 0;
2980 –                PyErr_Clear();
2981 –            }else {
2982 –                _v = 1;
2983 –            }
2984 –        }
2985 –        if (_v) {
2986 –            return _wrap_BossTask_jobsMap__SWIG_1(self,args);
2987 –        }
2988 –    }
2989 –    
2990 –    PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
2991 –    return NULL;
2992 – }
2993 –
2994 –
3616   static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3617      PyObject *resultobj;
3618      BossTask *arg1 = (BossTask *) 0 ;
# Line 3010 | Line 3631 | static PyObject *_wrap_BossTask_progDict
3631          try {
3632              result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3633              
3634 +        }catch (const BossSchedFailure & e) {
3635 +            SWIG_exception(SWIG_ValueError, e.what());
3636          }catch (const std::exception& e) {
3637              SWIG_exception(SWIG_RuntimeError, e.what());
3638          }
# Line 3044 | Line 3667 | static PyObject *_wrap_BossTask_jobProgr
3667          try {
3668              result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
3669              
3670 +        }catch (const BossSchedFailure & e) {
3671 +            SWIG_exception(SWIG_ValueError, e.what());
3672          }catch (const std::exception& e) {
3673              SWIG_exception(SWIG_RuntimeError, e.what());
3674          }
# Line 3067 | Line 3692 | static PyObject *_wrap_new_BossTask__SWI
3692          try {
3693              result = (BossTask *)new BossTask(arg1);
3694              
3695 +        }catch (const BossSchedFailure & e) {
3696 +            SWIG_exception(SWIG_ValueError, e.what());
3697          }catch (const std::exception& e) {
3698              SWIG_exception(SWIG_RuntimeError, e.what());
3699          }
# Line 3101 | Line 3728 | static PyObject *_wrap_new_BossTask__SWI
3728          try {
3729              result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3730              
3731 +        }catch (const BossSchedFailure & e) {
3732 +            SWIG_exception(SWIG_ValueError, e.what());
3733          }catch (const std::exception& e) {
3734              SWIG_exception(SWIG_RuntimeError, e.what());
3735          }
# Line 3123 | Line 3752 | static PyObject *_wrap_delete_BossTask(P
3752          try {
3753              delete arg1;
3754              
3755 +        }catch (const BossSchedFailure & e) {
3756 +            SWIG_exception(SWIG_ValueError, e.what());
3757          }catch (const std::exception& e) {
3758              SWIG_exception(SWIG_RuntimeError, e.what());
3759          }
# Line 3149 | Line 3780 | static PyObject *_wrap_new_BossTask__SWI
3780          try {
3781              result = (BossTask *)new BossTask((BossTask const &)*arg1);
3782              
3783 +        }catch (const BossSchedFailure & e) {
3784 +            SWIG_exception(SWIG_ValueError, e.what());
3785          }catch (const std::exception& e) {
3786              SWIG_exception(SWIG_RuntimeError, e.what());
3787          }
# Line 3240 | Line 3873 | static PyObject *_wrap_BossTask_id(PyObj
3873                  result = (std::string *) &_result_ref;
3874              }
3875              
3876 +        }catch (const BossSchedFailure & e) {
3877 +            SWIG_exception(SWIG_ValueError, e.what());
3878          }catch (const std::exception& e) {
3879              SWIG_exception(SWIG_RuntimeError, e.what());
3880          }
# Line 3268 | Line 3903 | static PyObject *_wrap_BossTask_name(PyO
3903                  result = (std::string *) &_result_ref;
3904              }
3905              
3906 +        }catch (const BossSchedFailure & e) {
3907 +            SWIG_exception(SWIG_ValueError, e.what());
3908          }catch (const std::exception& e) {
3909              SWIG_exception(SWIG_RuntimeError, e.what());
3910          }
# Line 3281 | Line 3918 | static PyObject *_wrap_BossTask_name(PyO
3918   }
3919  
3920  
3921 < static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
3921 > static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3922      PyObject *resultobj;
3923      BossTask *arg1 = (BossTask *) 0 ;
3924 <    SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3924 >    std::map<std::string,std::string > result;
3925      PyObject * obj0 = 0 ;
3926      
3927 <    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3927 >    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3928      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3929      {
3930          try {
3931 <            result = ((BossTask const *)arg1)->jobsMap();
3931 >            result = ((BossTask const *)arg1)->taskMap();
3932              
3933 +        }catch (const BossSchedFailure & e) {
3934 +            SWIG_exception(SWIG_ValueError, e.what());
3935          }catch (const std::exception& e) {
3936              SWIG_exception(SWIG_RuntimeError, e.what());
3937          }
3938      }
3939      {
3940 <        std::map<std::string,std::map<std::string,std::string > > * resultptr;
3941 <        resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3942 <        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3940 >        resultobj = PyDict_New();
3941 >        for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3942 >            PyDict_SetItem(resultobj,
3943 >            SwigString_FromString(i->first),
3944 >            SwigString_FromString(i->second));
3945 >        }
3946      }
3947      return resultobj;
3948      fail:
# Line 3308 | Line 3950 | static PyObject *_wrap_BossTask_jobsMap_
3950   }
3951  
3952  
3953 < static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
3953 > static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3954      PyObject *resultobj;
3955      BossTask *arg1 = (BossTask *) 0 ;
3956 <    unsigned int arg2 ;
3315 <    std::map<std::string,std::string > result;
3956 >    BossTask::job_iterator result;
3957      PyObject * obj0 = 0 ;
3317 –    PyObject * obj1 = 0 ;
3958      
3959 <    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
3959 >    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3960      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3321 –    arg2 = (unsigned int) PyInt_AsLong(obj1);
3322 –    if (PyErr_Occurred()) SWIG_fail;
3961      {
3962          try {
3963 <            result = ((BossTask const *)arg1)->jobMap(arg2);
3963 >            result = ((BossTask const *)arg1)->job_begin();
3964              
3965 +        }catch (const BossSchedFailure & e) {
3966 +            SWIG_exception(SWIG_ValueError, e.what());
3967          }catch (const std::exception& e) {
3968              SWIG_exception(SWIG_RuntimeError, e.what());
3969          }
3970      }
3971      {
3972 <        resultobj = PyDict_New();
3973 <        for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3974 <            PyDict_SetItem(resultobj,
3975 <            SwigString_FromString(i->first),
3976 <            SwigString_FromString(i->second));
3972 >        BossTask::job_iterator * resultptr;
3973 >        resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3974 >        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3975 >    }
3976 >    return resultobj;
3977 >    fail:
3978 >    return NULL;
3979 > }
3980 >
3981 >
3982 > static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3983 >    PyObject *resultobj;
3984 >    BossTask *arg1 = (BossTask *) 0 ;
3985 >    BossTask::job_iterator result;
3986 >    PyObject * obj0 = 0 ;
3987 >    
3988 >    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3989 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3990 >    {
3991 >        try {
3992 >            result = ((BossTask const *)arg1)->job_end();
3993 >            
3994 >        }catch (const BossSchedFailure & e) {
3995 >            SWIG_exception(SWIG_ValueError, e.what());
3996 >        }catch (const std::exception& e) {
3997 >            SWIG_exception(SWIG_RuntimeError, e.what());
3998          }
3999      }
4000 +    {
4001 +        BossTask::job_iterator * resultptr;
4002 +        resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4003 +        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4004 +    }
4005      return resultobj;
4006      fail:
4007      return NULL;
4008   }
4009  
4010  
4011 < static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4011 > static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4012 >    PyObject *resultobj;
4013 >    BossTask *arg1 = (BossTask *) 0 ;
4014 >    SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4015 >    PyObject * obj0 = 0 ;
4016 >    
4017 >    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4018 >    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4019 >    {
4020 >        try {
4021 >            result = ((BossTask const *)arg1)->jobsMap();
4022 >            
4023 >        }catch (const BossSchedFailure & e) {
4024 >            SWIG_exception(SWIG_ValueError, e.what());
4025 >        }catch (const std::exception& e) {
4026 >            SWIG_exception(SWIG_RuntimeError, e.what());
4027 >        }
4028 >    }
4029 >    {
4030 >        std::map<std::string,std::map<std::string,std::string > > * resultptr;
4031 >        resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4032 >        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4033 >    }
4034 >    return resultobj;
4035 >    fail:
4036 >    return NULL;
4037 > }
4038 >
4039 >
4040 > static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4041      PyObject *resultobj;
4042      BossTask *arg1 = (BossTask *) 0 ;
4043      SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
# Line 3365 | Line 4060 | static PyObject *_wrap_BossTask_jobMap__
4060          try {
4061              result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4062              
4063 +        }catch (const BossSchedFailure & e) {
4064 +            SWIG_exception(SWIG_ValueError, e.what());
4065          }catch (const std::exception& e) {
4066              SWIG_exception(SWIG_RuntimeError, e.what());
4067          }
# Line 3378 | Line 4075 | static PyObject *_wrap_BossTask_jobMap__
4075   }
4076  
4077  
4078 + static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4079 +    PyObject *resultobj;
4080 +    BossTask *arg1 = (BossTask *) 0 ;
4081 +    unsigned int arg2 ;
4082 +    std::map<std::string,std::string > result;
4083 +    PyObject * obj0 = 0 ;
4084 +    PyObject * obj1 = 0 ;
4085 +    
4086 +    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4087 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4088 +    arg2 = (unsigned int) PyInt_AsLong(obj1);
4089 +    if (PyErr_Occurred()) SWIG_fail;
4090 +    {
4091 +        try {
4092 +            result = ((BossTask const *)arg1)->jobMap(arg2);
4093 +            
4094 +        }catch (const BossSchedFailure & e) {
4095 +            SWIG_exception(SWIG_ValueError, e.what());
4096 +        }catch (const std::exception& e) {
4097 +            SWIG_exception(SWIG_RuntimeError, e.what());
4098 +        }
4099 +    }
4100 +    {
4101 +        resultobj = PyDict_New();
4102 +        for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4103 +            PyDict_SetItem(resultobj,
4104 +            SwigString_FromString(i->first),
4105 +            SwigString_FromString(i->second));
4106 +        }
4107 +    }
4108 +    return resultobj;
4109 +    fail:
4110 +    return NULL;
4111 + }
4112 +
4113 +
4114   static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
4115      int argc;
4116      PyObject *argv[4];
# Line 3403 | Line 4136 | static PyObject *_wrap_BossTask_jobMap(P
4136                  _v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
4137              }
4138              if (_v) {
4139 <                return _wrap_BossTask_jobMap__SWIG_0(self,args);
4139 >                return _wrap_BossTask_jobMap__SWIG_1(self,args);
4140              }
4141          }
4142      }
# Line 3439 | Line 4172 | static PyObject *_wrap_BossTask_jobMap(P
4172                      }
4173                  }
4174                  if (_v) {
4175 <                    return _wrap_BossTask_jobMap__SWIG_1(self,args);
4175 >                    return _wrap_BossTask_jobMap__SWIG_0(self,args);
4176                  }
4177              }
4178          }
# Line 3450 | Line 4183 | static PyObject *_wrap_BossTask_jobMap(P
4183   }
4184  
4185  
4186 < static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3454 <    PyObject *resultobj;
3455 <    BossTask *arg1 = (BossTask *) 0 ;
3456 <    BossTask::job_iterator result;
3457 <    PyObject * obj0 = 0 ;
3458 <    
3459 <    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3460 <    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3461 <    {
3462 <        try {
3463 <            result = ((BossTask const *)arg1)->job_begin();
3464 <            
3465 <        }catch (const std::exception& e) {
3466 <            SWIG_exception(SWIG_RuntimeError, e.what());
3467 <        }
3468 <    }
3469 <    {
3470 <        BossTask::job_iterator * resultptr;
3471 <        resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3472 <        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3473 <    }
3474 <    return resultobj;
3475 <    fail:
3476 <    return NULL;
3477 < }
3478 <
3479 <
3480 < static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4186 > static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4187      PyObject *resultobj;
4188      BossTask *arg1 = (BossTask *) 0 ;
4189 <    BossTask::job_iterator result;
4189 >    BossJob *arg2 = (BossJob *) 0 ;
4190 >    SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4191      PyObject * obj0 = 0 ;
4192 +    PyObject * obj1 = 0 ;
4193      
4194 <    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4194 >    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
4195      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4196 +    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4197      {
4198          try {
4199 <            result = ((BossTask const *)arg1)->job_end();
4199 >            result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4200              
4201 +        }catch (const BossSchedFailure & e) {
4202 +            SWIG_exception(SWIG_ValueError, e.what());
4203          }catch (const std::exception& e) {
4204              SWIG_exception(SWIG_RuntimeError, e.what());
4205          }
4206      }
4207      {
4208 <        BossTask::job_iterator * resultptr;
4209 <        resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4210 <        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4208 >        std::map<std::string,std::map<std::string,std::string > > * resultptr;
4209 >        resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4210 >        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4211      }
4212      return resultobj;
4213      fail:
# Line 3519 | Line 4230 | static PyObject *_wrap_BossTask_queryJob
4230          try {
4231              result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4232              
4233 +        }catch (const BossSchedFailure & e) {
4234 +            SWIG_exception(SWIG_ValueError, e.what());
4235          }catch (const std::exception& e) {
4236              SWIG_exception(SWIG_RuntimeError, e.what());
4237          }
# Line 3534 | Line 4247 | static PyObject *_wrap_BossTask_queryJob
4247   }
4248  
4249  
3537 – static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
3538 –    PyObject *resultobj;
3539 –    BossTask *arg1 = (BossTask *) 0 ;
3540 –    BossJob *arg2 = (BossJob *) 0 ;
3541 –    SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3542 –    PyObject * obj0 = 0 ;
3543 –    PyObject * obj1 = 0 ;
3544 –    
3545 –    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
3546 –    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3547 –    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3548 –    {
3549 –        try {
3550 –            result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
3551 –            
3552 –        }catch (const std::exception& e) {
3553 –            SWIG_exception(SWIG_RuntimeError, e.what());
3554 –        }
3555 –    }
3556 –    {
3557 –        std::map<std::string,std::map<std::string,std::string > > * resultptr;
3558 –        resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3559 –        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3560 –    }
3561 –    return resultobj;
3562 –    fail:
3563 –    return NULL;
3564 – }
3565 –
3566 –
4250   static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4251      PyObject *resultobj;
4252      BossTask *arg1 = (BossTask *) 0 ;
# Line 3600 | Line 4283 | static PyObject *_wrap_BossTask_declare_
4283          try {
4284              (arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4285              
4286 +        }catch (const BossSchedFailure & e) {
4287 +            SWIG_exception(SWIG_ValueError, e.what());
4288          }catch (const std::exception& e) {
4289              SWIG_exception(SWIG_RuntimeError, e.what());
4290          }
# Line 3639 | Line 4324 | static PyObject *_wrap_BossTask_declare_
4324          try {
4325              (arg1)->declare(arg2,(std::string const &)*arg3);
4326              
4327 +        }catch (const BossSchedFailure & e) {
4328 +            SWIG_exception(SWIG_ValueError, e.what());
4329          }catch (const std::exception& e) {
4330              SWIG_exception(SWIG_RuntimeError, e.what());
4331          }
# Line 3738 | Line 4425 | static PyObject *_wrap_BossTask_remove(P
4425          try {
4426              (arg1)->remove();
4427              
4428 +        }catch (const BossSchedFailure & e) {
4429 +            SWIG_exception(SWIG_ValueError, e.what());
4430          }catch (const std::exception& e) {
4431              SWIG_exception(SWIG_RuntimeError, e.what());
4432          }
# Line 3774 | Line 4463 | static PyObject *_wrap_BossTask_archive(
4463          try {
4464              (arg1)->archive((std::string const &)*arg2);
4465              
4466 +        }catch (const BossSchedFailure & e) {
4467 +            SWIG_exception(SWIG_ValueError, e.what());
4468          }catch (const std::exception& e) {
4469              SWIG_exception(SWIG_RuntimeError, e.what());
4470          }
# Line 3785 | Line 4476 | static PyObject *_wrap_BossTask_archive(
4476   }
4477  
4478  
3788 – static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3789 –    PyObject *resultobj;
3790 –    BossTask *arg1 = (BossTask *) 0 ;
3791 –    std::map<std::string,std::string > result;
3792 –    PyObject * obj0 = 0 ;
3793 –    
3794 –    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3795 –    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3796 –    {
3797 –        try {
3798 –            result = ((BossTask const *)arg1)->taskMap();
3799 –            
3800 –        }catch (const std::exception& e) {
3801 –            SWIG_exception(SWIG_RuntimeError, e.what());
3802 –        }
3803 –    }
3804 –    {
3805 –        resultobj = PyDict_New();
3806 –        for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3807 –            PyDict_SetItem(resultobj,
3808 –            SwigString_FromString(i->first),
3809 –            SwigString_FromString(i->second));
3810 –        }
3811 –    }
3812 –    return resultobj;
3813 –    fail:
3814 –    return NULL;
3815 – }
3816 –
3817 –
4479   static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4480      PyObject *resultobj;
4481      BossTask *arg1 = (BossTask *) 0 ;
# Line 3903 | Line 4564 | static PyObject *_wrap_BossTask_submit(P
4564          try {
4565              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);
4566              
4567 +        }catch (const BossSchedFailure & e) {
4568 +            SWIG_exception(SWIG_ValueError, e.what());
4569          }catch (const std::exception& e) {
4570              SWIG_exception(SWIG_RuntimeError, e.what());
4571          }
# Line 3943 | Line 4606 | static PyObject *_wrap_BossTask_reSubmit
4606          try {
4607              result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4608              
4609 +        }catch (const BossSchedFailure & e) {
4610 +            SWIG_exception(SWIG_ValueError, e.what());
4611          }catch (const std::exception& e) {
4612              SWIG_exception(SWIG_RuntimeError, e.what());
4613          }
# Line 3983 | Line 4648 | static PyObject *_wrap_BossTask_kill(PyO
4648          try {
4649              result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4650              
4651 +        }catch (const BossSchedFailure & e) {
4652 +            SWIG_exception(SWIG_ValueError, e.what());
4653          }catch (const std::exception& e) {
4654              SWIG_exception(SWIG_RuntimeError, e.what());
4655          }
# Line 3994 | Line 4661 | static PyObject *_wrap_BossTask_kill(PyO
4661   }
4662  
4663  
4664 < static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
4664 > static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4665      PyObject *resultobj;
4666      BossTask *arg1 = (BossTask *) 0 ;
4667      std::string const &arg2_defvalue = "all" ;
# Line 4046 | Line 4713 | static PyObject *_wrap_BossTask_getOutpu
4713          try {
4714              result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4715              
4716 +        }catch (const BossSchedFailure & e) {
4717 +            SWIG_exception(SWIG_ValueError, e.what());
4718          }catch (const std::exception& e) {
4719              SWIG_exception(SWIG_RuntimeError, e.what());
4720          }
# Line 4057 | Line 4726 | static PyObject *_wrap_BossTask_getOutpu
4726   }
4727  
4728  
4729 < static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
4729 > static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
4730      PyObject *resultobj;
4731      BossTask *arg1 = (BossTask *) 0 ;
4732 <    std::string const &arg2_defvalue = "" ;
4733 <    std::string *arg2 = (std::string *) &arg2_defvalue ;
4734 <    bool arg3 = (bool) false ;
4735 <    bool arg4 = (bool) false ;
4732 >    int arg2 = (int) SCHEDULED ;
4733 >    std::string const &arg3_defvalue = "all" ;
4734 >    std::string *arg3 = (std::string *) &arg3_defvalue ;
4735 >    std::string const &arg4_defvalue = "" ;
4736 >    std::string *arg4 = (std::string *) &arg4_defvalue ;
4737 >    std::string arg5 = (std::string) "" ;
4738 >    std::string arg6 = (std::string) "" ;
4739 >    std::string arg7 = (std::string) "" ;
4740 >    std::string arg8 = (std::string) "" ;
4741      int result;
4742 <    std::string temp2 ;
4742 >    std::string temp3 ;
4743 >    std::string temp4 ;
4744      PyObject * obj0 = 0 ;
4070 –    PyObject * obj1 = 0 ;
4745      PyObject * obj2 = 0 ;
4746      PyObject * obj3 = 0 ;
4747 +    PyObject * obj4 = 0 ;
4748 +    PyObject * obj5 = 0 ;
4749 +    PyObject * obj6 = 0 ;
4750 +    PyObject * obj7 = 0 ;
4751      
4752 <    if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4752 >    if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4753      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4754 <    if (obj1) {
4754 >    if (obj2) {
4755          {
4756 <            if (PyString_Check(obj1)) {
4757 <                temp2 = std::string(PyString_AsString(obj1));
4758 <                arg2 = &temp2;
4756 >            if (PyString_Check(obj2)) {
4757 >                temp3 = std::string(PyString_AsString(obj2));
4758 >                arg3 = &temp3;
4759              }else {
4760                  SWIG_exception(SWIG_TypeError, "string expected");
4761              }
4762          }
4763      }
4086 –    if (obj2) {
4087 –        arg3 = PyInt_AsLong(obj2) ? true : false;
4088 –        if (PyErr_Occurred()) SWIG_fail;
4089 –    }
4764      if (obj3) {
4765 <        arg4 = PyInt_AsLong(obj3) ? true : false;
4766 <        if (PyErr_Occurred()) SWIG_fail;
4767 <    }
4768 <    {
4769 <        try {
4770 <            result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
4771 <            
4098 <        }catch (const std::exception& e) {
4099 <            SWIG_exception(SWIG_RuntimeError, e.what());
4765 >        {
4766 >            if (PyString_Check(obj3)) {
4767 >                temp4 = std::string(PyString_AsString(obj3));
4768 >                arg4 = &temp4;
4769 >            }else {
4770 >                SWIG_exception(SWIG_TypeError, "string expected");
4771 >            }
4772          }
4773      }
4774 <    resultobj = PyInt_FromLong((long)result);
4775 <    return resultobj;
4776 <    fail:
4777 <    return NULL;
4778 < }
4779 <
4780 <
4109 < static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4110 <    int argc;
4111 <    PyObject *argv[6];
4112 <    int ii;
4113 <    
4114 <    argc = PyObject_Length(args);
4115 <    for (ii = 0; (ii < argc) && (ii < 5); ii++) {
4116 <        argv[ii] = PyTuple_GetItem(args,ii);
4774 >    if (obj4) {
4775 >        {
4776 >            if (PyString_Check(obj4))
4777 >            arg5 = std::string(PyString_AsString(obj4));
4778 >            else
4779 >            SWIG_exception(SWIG_TypeError, "string expected");
4780 >        }
4781      }
4782 <    if ((argc >= 1) && (argc <= 5)) {
4119 <        int _v;
4782 >    if (obj5) {
4783          {
4784 <            void *ptr;
4785 <            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4786 <                _v = 0;
4787 <                PyErr_Clear();
4125 <            }else {
4126 <                _v = 1;
4127 <            }
4784 >            if (PyString_Check(obj5))
4785 >            arg6 = std::string(PyString_AsString(obj5));
4786 >            else
4787 >            SWIG_exception(SWIG_TypeError, "string expected");
4788          }
4789 <        if (_v) {
4790 <            if (argc <= 1) {
4791 <                return _wrap_BossTask_getOutput__SWIG_0(self,args);
4792 <            }
4793 <            {
4794 <                _v = PyString_Check(argv[1]) ? 1 : 0;
4795 <            }
4136 <            if (_v) {
4137 <                if (argc <= 2) {
4138 <                    return _wrap_BossTask_getOutput__SWIG_0(self,args);
4139 <                }
4140 <                {
4141 <                    _v = PyString_Check(argv[2]) ? 1 : 0;
4142 <                }
4143 <                if (_v) {
4144 <                    if (argc <= 3) {
4145 <                        return _wrap_BossTask_getOutput__SWIG_0(self,args);
4146 <                    }
4147 <                    {
4148 <                        _v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4149 <                    }
4150 <                    if (_v) {
4151 <                        if (argc <= 4) {
4152 <                            return _wrap_BossTask_getOutput__SWIG_0(self,args);
4153 <                        }
4154 <                        {
4155 <                            _v = (PyInt_Check(argv[4]) || PyLong_Check(argv[4])) ? 1 : 0;
4156 <                        }
4157 <                        if (_v) {
4158 <                            return _wrap_BossTask_getOutput__SWIG_0(self,args);
4159 <                        }
4160 <                    }
4161 <                }
4162 <            }
4789 >    }
4790 >    if (obj6) {
4791 >        {
4792 >            if (PyString_Check(obj6))
4793 >            arg7 = std::string(PyString_AsString(obj6));
4794 >            else
4795 >            SWIG_exception(SWIG_TypeError, "string expected");
4796          }
4797      }
4798 <    if ((argc >= 1) && (argc <= 4)) {
4166 <        int _v;
4798 >    if (obj7) {
4799          {
4800 <            void *ptr;
4801 <            if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4802 <                _v = 0;
4803 <                PyErr_Clear();
4172 <            }else {
4173 <                _v = 1;
4174 <            }
4800 >            if (PyString_Check(obj7))
4801 >            arg8 = std::string(PyString_AsString(obj7));
4802 >            else
4803 >            SWIG_exception(SWIG_TypeError, "string expected");
4804          }
4805 <        if (_v) {
4806 <            if (argc <= 1) {
4807 <                return _wrap_BossTask_getOutput__SWIG_1(self,args);
4808 <            }
4809 <            {
4810 <                _v = PyString_Check(argv[1]) ? 1 : 0;
4811 <            }
4812 <            if (_v) {
4813 <                if (argc <= 2) {
4185 <                    return _wrap_BossTask_getOutput__SWIG_1(self,args);
4186 <                }
4187 <                {
4188 <                    _v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
4189 <                }
4190 <                if (_v) {
4191 <                    if (argc <= 3) {
4192 <                        return _wrap_BossTask_getOutput__SWIG_1(self,args);
4193 <                    }
4194 <                    {
4195 <                        _v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4196 <                    }
4197 <                    if (_v) {
4198 <                        return _wrap_BossTask_getOutput__SWIG_1(self,args);
4199 <                    }
4200 <                }
4201 <            }
4805 >    }
4806 >    {
4807 >        try {
4808 >            result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4809 >            
4810 >        }catch (const BossSchedFailure & e) {
4811 >            SWIG_exception(SWIG_ValueError, e.what());
4812 >        }catch (const std::exception& e) {
4813 >            SWIG_exception(SWIG_RuntimeError, e.what());
4814          }
4815      }
4816 <    
4817 <    PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
4816 >    resultobj = PyInt_FromLong((long)result);
4817 >    return resultobj;
4818 >    fail:
4819      return NULL;
4820   }
4821  
# Line 4294 | Line 4907 | static PyObject *_wrap_BossTask_query(Py
4907          try {
4908              result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
4909              
4910 +        }catch (const BossSchedFailure & e) {
4911 +            SWIG_exception(SWIG_ValueError, e.what());
4912          }catch (const std::exception& e) {
4913              SWIG_exception(SWIG_RuntimeError, e.what());
4914          }
# Line 4353 | Line 4968 | static PyObject *_wrap_BossTask_query_ou
4968          try {
4969              ((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
4970              
4971 +        }catch (const BossSchedFailure & e) {
4972 +            SWIG_exception(SWIG_ValueError, e.what());
4973          }catch (const std::exception& e) {
4974              SWIG_exception(SWIG_RuntimeError, e.what());
4975          }
# Line 4375 | Line 4992 | static PyObject *_wrap_BossTask_clear(Py
4992          try {
4993              (arg1)->clear();
4994              
4995 +        }catch (const BossSchedFailure & e) {
4996 +            SWIG_exception(SWIG_ValueError, e.what());
4997          }catch (const std::exception& e) {
4998              SWIG_exception(SWIG_RuntimeError, e.what());
4999          }
# Line 4386 | Line 5005 | static PyObject *_wrap_BossTask_clear(Py
5005   }
5006  
5007  
4389 – static PyObject *_wrap_BossTask_prompt(PyObject *self, PyObject *args) {
4390 –    PyObject *resultobj;
4391 –    BossTask *arg1 = (BossTask *) 0 ;
4392 –    std::string *arg2 = 0 ;
4393 –    bool result;
4394 –    std::string temp2 ;
4395 –    PyObject * obj0 = 0 ;
4396 –    PyObject * obj1 = 0 ;
4397 –    
4398 –    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_prompt",&obj0,&obj1)) goto fail;
4399 –    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4400 –    {
4401 –        if (PyString_Check(obj1)) {
4402 –            temp2 = std::string(PyString_AsString(obj1));
4403 –            arg2 = &temp2;
4404 –        }else {
4405 –            SWIG_exception(SWIG_TypeError, "string expected");
4406 –        }
4407 –    }
4408 –    {
4409 –        try {
4410 –            result = (bool)(arg1)->prompt((std::string const &)*arg2);
4411 –            
4412 –        }catch (const std::exception& e) {
4413 –            SWIG_exception(SWIG_RuntimeError, e.what());
4414 –        }
4415 –    }
4416 –    resultobj = PyInt_FromLong((long)result);
4417 –    return resultobj;
4418 –    fail:
4419 –    return NULL;
4420 – }
4421 –
4422 –
5008   static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
5009      PyObject *obj;
5010      if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
# Line 4430 | Line 5015 | static PyObject * BossTask_swigregister(
5015   static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
5016      PyObject *resultobj;
5017      std::string arg1 = (std::string) "" ;
5018 <    bool arg2 = (bool) false ;
5018 >    std::string arg2 = (std::string) "2" ;
5019 >    std::string arg3 = (std::string) "" ;
5020 >    bool arg4 = (bool) false ;
5021      BossAdministratorSession *result;
5022      PyObject * obj0 = 0 ;
5023      PyObject * obj1 = 0 ;
5024 +    PyObject * obj2 = 0 ;
5025 +    PyObject * obj3 = 0 ;
5026      
5027 <    if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
5027 >    if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
5028      if (obj0) {
5029          {
5030              if (PyString_Check(obj0))
# Line 4445 | Line 5034 | static PyObject *_wrap_new_BossAdministr
5034          }
5035      }
5036      if (obj1) {
5037 <        arg2 = PyInt_AsLong(obj1) ? true : false;
5037 >        {
5038 >            if (PyString_Check(obj1))
5039 >            arg2 = std::string(PyString_AsString(obj1));
5040 >            else
5041 >            SWIG_exception(SWIG_TypeError, "string expected");
5042 >        }
5043 >    }
5044 >    if (obj2) {
5045 >        {
5046 >            if (PyString_Check(obj2))
5047 >            arg3 = std::string(PyString_AsString(obj2));
5048 >            else
5049 >            SWIG_exception(SWIG_TypeError, "string expected");
5050 >        }
5051 >    }
5052 >    if (obj3) {
5053 >        arg4 = PyInt_AsLong(obj3) ? true : false;
5054          if (PyErr_Occurred()) SWIG_fail;
5055      }
5056      {
5057          try {
5058 <            result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
5058 >            result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4);
5059              
5060 +        }catch (const BossSchedFailure & e) {
5061 +            SWIG_exception(SWIG_ValueError, e.what());
5062          }catch (const std::exception& e) {
5063              SWIG_exception(SWIG_RuntimeError, e.what());
5064          }
# Line 4474 | Line 5081 | static PyObject *_wrap_delete_BossAdmini
5081          try {
5082              delete arg1;
5083              
5084 +        }catch (const BossSchedFailure & e) {
5085 +            SWIG_exception(SWIG_ValueError, e.what());
5086          }catch (const std::exception& e) {
5087              SWIG_exception(SWIG_RuntimeError, e.what());
5088          }
# Line 4485 | Line 5094 | static PyObject *_wrap_delete_BossAdmini
5094   }
5095  
5096  
5097 + static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
5098 +    PyObject *resultobj;
5099 +    BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5100 +    int result;
5101 +    PyObject * obj0 = 0 ;
5102 +    
5103 +    if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
5104 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5105 +    {
5106 +        try {
5107 +            result = (int)(arg1)->configureDB();
5108 +            
5109 +        }catch (const BossSchedFailure & e) {
5110 +            SWIG_exception(SWIG_ValueError, e.what());
5111 +        }catch (const std::exception& e) {
5112 +            SWIG_exception(SWIG_RuntimeError, e.what());
5113 +        }
5114 +    }
5115 +    resultobj = PyInt_FromLong((long)result);
5116 +    return resultobj;
5117 +    fail:
5118 +    return NULL;
5119 + }
5120 +
5121 +
5122   static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
5123      PyObject *resultobj;
5124      BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
# Line 4508 | Line 5142 | static PyObject *_wrap_BossAdministrator
5142          try {
5143              result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5144              
5145 +        }catch (const BossSchedFailure & e) {
5146 +            SWIG_exception(SWIG_ValueError, e.what());
5147          }catch (const std::exception& e) {
5148              SWIG_exception(SWIG_RuntimeError, e.what());
5149          }
# Line 4542 | Line 5178 | static PyObject *_wrap_BossAdministrator
5178          try {
5179              result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5180              
5181 +        }catch (const BossSchedFailure & e) {
5182 +            SWIG_exception(SWIG_ValueError, e.what());
5183          }catch (const std::exception& e) {
5184              SWIG_exception(SWIG_RuntimeError, e.what());
5185          }
# Line 4576 | Line 5214 | static PyObject *_wrap_BossAdministrator
5214          try {
5215              result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5216              
5217 +        }catch (const BossSchedFailure & e) {
5218 +            SWIG_exception(SWIG_ValueError, e.what());
5219          }catch (const std::exception& e) {
5220              SWIG_exception(SWIG_RuntimeError, e.what());
5221          }
# Line 4610 | Line 5250 | static PyObject *_wrap_BossAdministrator
5250          try {
5251              result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5252              
5253 +        }catch (const BossSchedFailure & e) {
5254 +            SWIG_exception(SWIG_ValueError, e.what());
5255          }catch (const std::exception& e) {
5256              SWIG_exception(SWIG_RuntimeError, e.what());
5257          }
# Line 4644 | Line 5286 | static PyObject *_wrap_BossAdministrator
5286          try {
5287              result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5288              
5289 +        }catch (const BossSchedFailure & e) {
5290 +            SWIG_exception(SWIG_ValueError, e.what());
5291          }catch (const std::exception& e) {
5292              SWIG_exception(SWIG_RuntimeError, e.what());
5293          }
# Line 4710 | Line 5354 | static PyObject *_wrap_BossAdministrator
5354          try {
5355              result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5356              
5357 +        }catch (const BossSchedFailure & e) {
5358 +            SWIG_exception(SWIG_ValueError, e.what());
5359          }catch (const std::exception& e) {
5360              SWIG_exception(SWIG_RuntimeError, e.what());
5361          }
# Line 4800 | Line 5446 | static PyObject *_wrap_BossAdministrator
5446          try {
5447              result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5448              
5449 +        }catch (const BossSchedFailure & e) {
5450 +            SWIG_exception(SWIG_ValueError, e.what());
5451          }catch (const std::exception& e) {
5452              SWIG_exception(SWIG_RuntimeError, e.what());
5453          }
# Line 4876 | Line 5524 | static PyObject *_wrap_BossAdministrator
5524          try {
5525              result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5526              
5527 +        }catch (const BossSchedFailure & e) {
5528 +            SWIG_exception(SWIG_ValueError, e.what());
5529          }catch (const std::exception& e) {
5530              SWIG_exception(SWIG_RuntimeError, e.what());
5531          }
# Line 4905 | Line 5555 | static PyObject *_wrap_BossAdministrator
5555      std::string arg13 = (std::string) "" ;
5556      bool arg14 = (bool) false ;
5557      bool arg15 = (bool) false ;
5558 +    bool arg16 = (bool) false ;
5559 +    bool arg17 = (bool) false ;
5560      int result;
5561      std::string temp2 ;
5562      std::string temp11 ;
# Line 4923 | Line 5575 | static PyObject *_wrap_BossAdministrator
5575      PyObject * obj12 = 0 ;
5576      PyObject * obj13 = 0 ;
5577      PyObject * obj14 = 0 ;
5578 +    PyObject * obj15 = 0 ;
5579 +    PyObject * obj16 = 0 ;
5580      
5581 <    if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) goto fail;
5581 >    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;
5582      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5583      {
5584          if (PyString_Check(obj1)) {
# Line 5032 | Line 5686 | static PyObject *_wrap_BossAdministrator
5686          arg15 = PyInt_AsLong(obj14) ? true : false;
5687          if (PyErr_Occurred()) SWIG_fail;
5688      }
5689 +    if (obj15) {
5690 +        arg16 = PyInt_AsLong(obj15) ? true : false;
5691 +        if (PyErr_Occurred()) SWIG_fail;
5692 +    }
5693 +    if (obj16) {
5694 +        arg17 = PyInt_AsLong(obj16) ? true : false;
5695 +        if (PyErr_Occurred()) SWIG_fail;
5696 +    }
5697      {
5698          try {
5699 <            result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
5699 >            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);
5700              
5701 +        }catch (const BossSchedFailure & e) {
5702 +            SWIG_exception(SWIG_ValueError, e.what());
5703          }catch (const std::exception& e) {
5704              SWIG_exception(SWIG_RuntimeError, e.what());
5705          }
# Line 5059 | Line 5723 | static PyObject *_wrap_BossAdministrator
5723          try {
5724              result = (arg1)->help();
5725              
5726 +        }catch (const BossSchedFailure & e) {
5727 +            SWIG_exception(SWIG_ValueError, e.what());
5728          }catch (const std::exception& e) {
5729              SWIG_exception(SWIG_RuntimeError, e.what());
5730          }
# Line 5072 | Line 5738 | static PyObject *_wrap_BossAdministrator
5738   }
5739  
5740  
5741 < static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
5741 > static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
5742      PyObject *resultobj;
5743      BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5744 <    std::string *arg2 = 0 ;
5744 >    std::string arg2 ;
5745 >    bool arg3 = (bool) false ;
5746      std::string result;
5747      PyObject * obj0 = 0 ;
5748      PyObject * obj1 = 0 ;
5749 +    PyObject * obj2 = 0 ;
5750      
5751 <    if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureDB",&obj0,&obj1)) goto fail;
5751 >    if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
5752      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5753 <    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5754 <    if (arg2 == NULL) {
5755 <        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5753 >    {
5754 >        if (PyString_Check(obj1))
5755 >        arg2 = std::string(PyString_AsString(obj1));
5756 >        else
5757 >        SWIG_exception(SWIG_TypeError, "string expected");
5758 >    }
5759 >    if (obj2) {
5760 >        arg3 = PyInt_AsLong(obj2) ? true : false;
5761 >        if (PyErr_Occurred()) SWIG_fail;
5762      }
5763      {
5764          try {
5765 <            result = (arg1)->configureDB(*arg2);
5765 >            result = (arg1)->SQL(arg2,arg3);
5766              
5767 +        }catch (const BossSchedFailure & e) {
5768 +            SWIG_exception(SWIG_ValueError, e.what());
5769          }catch (const std::exception& e) {
5770              SWIG_exception(SWIG_RuntimeError, e.what());
5771          }
# Line 5103 | Line 5779 | static PyObject *_wrap_BossAdministrator
5779   }
5780  
5781  
5782 < static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
5782 > static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
5783      PyObject *resultobj;
5784      BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5785      std::string *arg2 = 0 ;
5786 <    bool arg3 = (bool) false ;
5787 <    std::string result;
5786 >    std::string *arg3 = 0 ;
5787 >    std::string *arg4 = 0 ;
5788 >    std::string const &arg5_defvalue = "0" ;
5789 >    std::string *arg5 = (std::string *) &arg5_defvalue ;
5790 >    int result;
5791 >    std::string temp2 ;
5792 >    std::string temp3 ;
5793 >    std::string temp4 ;
5794 >    std::string temp5 ;
5795      PyObject * obj0 = 0 ;
5796      PyObject * obj1 = 0 ;
5797      PyObject * obj2 = 0 ;
5798 +    PyObject * obj3 = 0 ;
5799 +    PyObject * obj4 = 0 ;
5800      
5801 <    if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
5801 >    if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5802      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5803 <    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5804 <    if (arg2 == NULL) {
5805 <        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5803 >    {
5804 >        if (PyString_Check(obj1)) {
5805 >            temp2 = std::string(PyString_AsString(obj1));
5806 >            arg2 = &temp2;
5807 >        }else {
5808 >            SWIG_exception(SWIG_TypeError, "string expected");
5809 >        }
5810      }
5811 <    if (obj2) {
5812 <        arg3 = PyInt_AsLong(obj2) ? true : false;
5813 <        if (PyErr_Occurred()) SWIG_fail;
5811 >    {
5812 >        if (PyString_Check(obj2)) {
5813 >            temp3 = std::string(PyString_AsString(obj2));
5814 >            arg3 = &temp3;
5815 >        }else {
5816 >            SWIG_exception(SWIG_TypeError, "string expected");
5817 >        }
5818 >    }
5819 >    {
5820 >        if (PyString_Check(obj3)) {
5821 >            temp4 = std::string(PyString_AsString(obj3));
5822 >            arg4 = &temp4;
5823 >        }else {
5824 >            SWIG_exception(SWIG_TypeError, "string expected");
5825 >        }
5826 >    }
5827 >    if (obj4) {
5828 >        {
5829 >            if (PyString_Check(obj4)) {
5830 >                temp5 = std::string(PyString_AsString(obj4));
5831 >                arg5 = &temp5;
5832 >            }else {
5833 >                SWIG_exception(SWIG_TypeError, "string expected");
5834 >            }
5835 >        }
5836      }
5837      {
5838          try {
5839 <            result = (arg1)->SQL(*arg2,arg3);
5839 >            result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
5840              
5841 +        }catch (const BossSchedFailure & e) {
5842 +            SWIG_exception(SWIG_ValueError, e.what());
5843          }catch (const std::exception& e) {
5844              SWIG_exception(SWIG_RuntimeError, e.what());
5845          }
5846      }
5847 <    {
5135 <        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5136 <    }
5847 >    resultobj = PyInt_FromLong((long)result);
5848      return resultobj;
5849      fail:
5850      return NULL;
5851   }
5852  
5853  
5854 < static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
5854 > static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
5855      PyObject *resultobj;
5856      BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5857 <    std::string *arg2 = 0 ;
5858 <    std::string result;
5857 >    std::string arg2 ;
5858 >    int result;
5859      PyObject * obj0 = 0 ;
5860      PyObject * obj1 = 0 ;
5861      
5862 <    if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_purge",&obj0,&obj1)) goto fail;
5862 >    if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
5863      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5864 <    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5865 <    if (arg2 == NULL) {
5866 <        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5864 >    {
5865 >        if (PyString_Check(obj1))
5866 >        arg2 = std::string(PyString_AsString(obj1));
5867 >        else
5868 >        SWIG_exception(SWIG_TypeError, "string expected");
5869      }
5870      {
5871          try {
5872 <            result = (arg1)->purge(*arg2);
5872 >            result = (int)(arg1)->registerPlugins(arg2);
5873              
5874 +        }catch (const BossSchedFailure & e) {
5875 +            SWIG_exception(SWIG_ValueError, e.what());
5876          }catch (const std::exception& e) {
5877              SWIG_exception(SWIG_RuntimeError, e.what());
5878          }
5879      }
5880 <    {
5166 <        resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5167 <    }
5880 >    resultobj = PyInt_FromLong((long)result);
5881      return resultobj;
5882      fail:
5883      return NULL;
# Line 5194 | Line 5907 | static PyMethodDef SwigMethods[] = {
5907           { (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
5908           { (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
5909           { (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
5910 +         { (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
5911 +         { (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
5912 +         { (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
5913 +         { (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
5914 +         { (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
5915 +         { (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
5916 +         { (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
5917 +         { (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
5918 +         { (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
5919 +         { (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
5920 +         { (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
5921 +         { (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
5922 +         { (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
5923 +         { (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5924           { (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5925 <         { (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
5926 <         { (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
5927 <         { (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
5928 <         { (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
5925 >         { (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5926 >         { (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5927 >         { (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5928 >         { (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5929 >         { (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5930           { (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
5931           { (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
5932           { (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
5933 +         { (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
5934 +         { (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
5935           { (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
5936           { (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
5937           { (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
# Line 5211 | Line 5941 | static PyMethodDef SwigMethods[] = {
5941           { (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
5942           { (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
5943           { (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
5214 –         { (char *)"BossSession_purgeTasks", _wrap_BossSession_purgeTasks, METH_VARARGS },
5944           { (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
5945           { (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
5946 <         { (char *)"BossSession_jobQuery", _wrap_BossSession_jobQuery, METH_VARARGS },
5218 <         { (char *)"BossSession_queryPrint", _wrap_BossSession_queryPrint, METH_VARARGS },
5946 >         { (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
5947           { (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
5948 +         { (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
5949           { (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
5950           { (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5951           { (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
# Line 5226 | Line 5955 | static PyMethodDef SwigMethods[] = {
5955           { (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5956           { (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5957           { (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5958 <         { (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5958 >         { (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
5959           { (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5960           { (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
5961           { (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
5962           { (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
5963           { (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
5964           { (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
5965 <         { (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
5965 >         { (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
5966           { (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5967           { (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
5968 <         { (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
5968 >         { (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5969 >         { (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
5970           { (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
5971 +         { (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
5972           { (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
5973           { (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
5974           { (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
5244 –         { (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
5975           { (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
5976           { (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
5977           { (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
5978           { (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
5979 +         { (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
5980           { (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
5981           { (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
5982           { (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
5252 –         { (char *)"BossTask_prompt", _wrap_BossTask_prompt, METH_VARARGS },
5983           { (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
5984           { (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
5985           { (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
5986 +         { (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
5987           { (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
5988           { (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
5989           { (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
# Line 5263 | Line 5994 | static PyMethodDef SwigMethods[] = {
5994           { (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
5995           { (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
5996           { (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
5266 –         { (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
5997           { (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
5998           { (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
5999 +         { (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
6000           { (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
6001           { NULL, NULL }
6002   };
# Line 5273 | Line 6004 | static PyMethodDef SwigMethods[] = {
6004  
6005   /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6006  
5276 – static swig_type_info _swigt__p_std__vectorTBossJob_p_t[] = {{"_p_std__vectorTBossJob_p_t", 0, "std::vector<BossJob * > *", 0},{"_p_std__vectorTBossJob_p_t"},{0}};
5277 – 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}};
6007   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}};
6008 + 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}};
6009   static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6010 + 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}};
6011   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}};
5281 – static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6012   static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6013   static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
6014 < static swig_type_info _swigt__p_std__string[] = {{"_p_std__string", 0, "std::string *", 0},{"_p_std__string"},{0}};
6014 > static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6015   static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6016   static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
5287 – static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6017   static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6018 + static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6019   static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6020   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}};
6021   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}};
6022   static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
5293 – static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
5294 – 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}};
6023   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}};
6024 + 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}};
6025 + static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6026  
6027   static swig_type_info *swig_types_initial[] = {
5298 – _swigt__p_std__vectorTBossJob_p_t,
5299 – _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6028   _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6029 + _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6030   _swigt__p_XMLDoc,
6031 + _swigt__p_std__vectorTBossTask_p_t,
6032   _swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
5303 – _swigt__p_std__ostream,
6033   _swigt__p_BossTask,
6034   _swigt__p_BossTaskException,
6035 < _swigt__p_std__string,
6035 > _swigt__p_std__ostream,
6036   _swigt__p_BossAttributeContainer,
6037   _swigt__p_printOption,
5309 – _swigt__p_BossDatabase,
6038   _swigt__p_BossJob,
6039 + _swigt__p_BossDatabase,
6040   _swigt__p_BossSession,
6041   _swigt__p_std__vectorTstd__string_t,
6042   _swigt__p_std__mapTstd__string_std__string_t,
6043   _swigt__p_BossAdministratorSession,
5315 – _swigt__p_jobStates,
5316 – _swigt__p_std__vectorTBossJob_p_t__const_iterator,
6044   _swigt__p_BossTask__job_iterator,
6045 + _swigt__p_std__vectorTBossJob_p_t__const_iterator,
6046 + _swigt__p_jobStates,
6047   0
6048   };
6049  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines