ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/COMP/BOSS/BossPython/BossSession_wrap.cxx

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.19 by gcodispo, Wed Dec 13 18:26:33 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]
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]
657	>	#define  SWIGTYPE_p_XMLDoc swig_types[0]
658	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[1]
659	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator 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]
665	>	#define  SWIGTYPE_p_printOption swig_types[8]
666		#define  SWIGTYPE_p_BossAttributeContainer swig_types[9]
667	<	#define  SWIGTYPE_p_printOption swig_types[10]
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_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674	>	#define  SWIGTYPE_p_BossTask__job_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	+	static PyObject * BossError;
921	+	static PyObject * SchedulerError;
922		#include "BossSession.h"
923		#include "BossAdministratorSession.h"
924		#include "BossTask.h"
#	Line 863 | Line 929 | PyObject *std_maplstd_stringcstd_string_
929		#include "BossProgram.h"
930		#include "BossProgramExec.h"
931		#include "BossDatabase.h"
932	+	#include "BossScheduler.h"
933	+	#include "BossDeclaration.h"
934
935		PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
936		PyObject *  my_list = PyList_New( my_vec.size());
#	Line 873 | Line 941 | PyObject *BossSession_show(BossSession *
941		}
942		return my_list;
943		}
944	<	PyObject *BossSession_showCHTools__SWIG_1(BossSession *self){
944	>	PyObject *BossSession_CHTools(BossSession *self){
945		std::vector<std::string> my_vec = self->showCHTools();
946		return BossSession_show( self, my_vec );
947		}
948	<	PyObject *BossSession_showProgramTypes__SWIG_1(BossSession *self){
948	>	PyObject *BossSession_ProgramTypes(BossSession *self){
949		std::vector<std::string> my_vec = self->showProgramTypes();
950		return BossSession_show( self, my_vec );
951		}
952	<	PyObject *BossSession_showRTMon__SWIG_1(BossSession *self){
952	>	PyObject *BossSession_RTMons(BossSession *self){
953		std::vector<std::string> my_vec = self->showRTMon();
954		return BossSession_show( self, my_vec );
955		}
956	<	PyObject *BossSession_showSchedulers__SWIG_1(BossSession *self){
956	>	PyObject *BossSession_schedulers(BossSession *self){
957		std::vector<std::string> my_vec = self->showSchedulers();
958		return BossSession_show( self, my_vec );
959		}
960	+	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
961	+	std::vector<std::string> my_vec = self->listMatch( scheduler,
962	+	schclassad,
963	+	keepfile,
964	+	taskid,
965	+	jobid);
966	+	return BossSession_show( self, my_vec );
967	+	}
968		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){
969	<	self->jobQuery ( filter_opt, taskRange, jobRange, subn,
970	<	type, user, after, before, avoidCheck);
969	>	if ( !avoidCheck ) {
970	>	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
971	>	type, user, after, before);
972	>	}
973		PyObject * job_dict = PyList_New(0);
974		std::vector <std::string>
975		taskList = self->selectTasks( taskRange, before, after, user);
#	Line 899 | Line 977 | PyObject *BossSession_queryTasks(BossSes
977		it!= taskList.end(); ++it ) {
978		PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
979		}
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	–	//       }
980		return  job_dict;
981		}
982		PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
#	Line 945 | Line 1016 | PyObject *BossTask_jobDict(BossTask cons
1016		}
1017		return job_dict;
1018		}
1019	<	PyObject *BossTask_jobsMap__SWIG_1(BossTask const *self){
1019	>	PyObject *BossTask_jobsDict(BossTask *self){
1020
1021		PyObject * job_dict = PyDict_New();
1022	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1023		for (BossTask::job_iterator jit = self->job_begin ();
1024		jit != self->job_end (); ++jit) {
1025		std::string id = (*jit)->chainId();
#	Line 1016 | Line 1088 | static PyObject *_wrap_new_objectMap__SW
1088		try {
1089		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1090
1091	+	}catch (const BossSchedFailure & e) {
1092	+	PyErr_SetString ( SchedulerError, e.what() );
1093	+	return NULL;
1094		}catch (const std::exception& e) {
1095	<	SWIG_exception(SWIG_RuntimeError, e.what());
1095	>	PyErr_SetString ( BossError, e.what() );
1096	>	return NULL;
1097		}
1098		}
1099		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1075 | Line 1151 | static PyObject *_wrap_new_objectMap__SW
1151		try {
1152		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1153
1154	+	}catch (const BossSchedFailure & e) {
1155	+	PyErr_SetString ( SchedulerError, e.what() );
1156	+	return NULL;
1157		}catch (const std::exception& e) {
1158	<	SWIG_exception(SWIG_RuntimeError, e.what());
1158	>	PyErr_SetString ( BossError, e.what() );
1159	>	return NULL;
1160		}
1161		}
1162		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1190 | Line 1270 | static PyObject *_wrap_objectMap___len__
1270		try {
1271		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1272
1273	+	}catch (const BossSchedFailure & e) {
1274	+	PyErr_SetString ( SchedulerError, e.what() );
1275	+	return NULL;
1276		}catch (const std::exception& e) {
1277	<	SWIG_exception(SWIG_RuntimeError, e.what());
1277	>	PyErr_SetString ( BossError, e.what() );
1278	>	return NULL;
1279		}
1280		}
1281		resultobj = PyInt_FromLong((long)result);
#	Line 1212 | Line 1296 | static PyObject *_wrap_objectMap_clear(P
1296		try {
1297		(arg1)->clear();
1298
1299	+	}catch (const BossSchedFailure & e) {
1300	+	PyErr_SetString ( SchedulerError, e.what() );
1301	+	return NULL;
1302		}catch (const std::exception& e) {
1303	<	SWIG_exception(SWIG_RuntimeError, e.what());
1303	>	PyErr_SetString ( BossError, e.what() );
1304	>	return NULL;
1305		}
1306		}
1307		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1235 | Line 1323 | static PyObject *_wrap_objectMap___nonze
1323		try {
1324		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1325
1326	+	}catch (const BossSchedFailure & e) {
1327	+	PyErr_SetString ( SchedulerError, e.what() );
1328	+	return NULL;
1329		}catch (const std::exception& e) {
1330	<	SWIG_exception(SWIG_RuntimeError, e.what());
1330	>	PyErr_SetString ( BossError, e.what() );
1331	>	return NULL;
1332		}
1333		}
1334		resultobj = PyInt_FromLong((long)result);
#	Line 1307 | Line 1399 | static PyObject *_wrap_objectMap___setit
1399		try {
1400		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1401
1402	+	}catch (const BossSchedFailure & e) {
1403	+	PyErr_SetString ( SchedulerError, e.what() );
1404	+	return NULL;
1405		}catch (const std::exception& e) {
1406	<	SWIG_exception(SWIG_RuntimeError, e.what());
1406	>	PyErr_SetString ( BossError, e.what() );
1407	>	return NULL;
1408		}
1409		}
1410		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1369 | Line 1465 | static PyObject *_wrap_objectMap_has_key
1465		try {
1466		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1467
1468	+	}catch (const BossSchedFailure & e) {
1469	+	PyErr_SetString ( SchedulerError, e.what() );
1470	+	return NULL;
1471		}catch (const std::exception& e) {
1472	<	SWIG_exception(SWIG_RuntimeError, e.what());
1472	>	PyErr_SetString ( BossError, e.what() );
1473	>	return NULL;
1474		}
1475		}
1476		resultobj = PyInt_FromLong((long)result);
#	Line 1392 | Line 1492 | static PyObject *_wrap_objectMap_keys(Py
1492		try {
1493		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1494
1495	+	}catch (const BossSchedFailure & e) {
1496	+	PyErr_SetString ( SchedulerError, e.what() );
1497	+	return NULL;
1498		}catch (const std::exception& e) {
1499	<	SWIG_exception(SWIG_RuntimeError, e.what());
1499	>	PyErr_SetString ( BossError, e.what() );
1500	>	return NULL;
1501		}
1502		}
1503		resultobj = result;
#	Line 1415 | Line 1519 | static PyObject *_wrap_objectMap_values(
1519		try {
1520		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1521
1522	+	}catch (const BossSchedFailure & e) {
1523	+	PyErr_SetString ( SchedulerError, e.what() );
1524	+	return NULL;
1525		}catch (const std::exception& e) {
1526	<	SWIG_exception(SWIG_RuntimeError, e.what());
1526	>	PyErr_SetString ( BossError, e.what() );
1527	>	return NULL;
1528		}
1529		}
1530		resultobj = result;
#	Line 1438 | Line 1546 | static PyObject *_wrap_objectMap_items(P
1546		try {
1547		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1548
1549	+	}catch (const BossSchedFailure & e) {
1550	+	PyErr_SetString ( SchedulerError, e.what() );
1551	+	return NULL;
1552		}catch (const std::exception& e) {
1553	<	SWIG_exception(SWIG_RuntimeError, e.what());
1553	>	PyErr_SetString ( BossError, e.what() );
1554	>	return NULL;
1555		}
1556		}
1557		resultobj = result;
#	Line 1469 | Line 1581 | static PyObject *_wrap_objectMap___conta
1581		try {
1582		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1583
1584	+	}catch (const BossSchedFailure & e) {
1585	+	PyErr_SetString ( SchedulerError, e.what() );
1586	+	return NULL;
1587		}catch (const std::exception& e) {
1588	<	SWIG_exception(SWIG_RuntimeError, e.what());
1588	>	PyErr_SetString ( BossError, e.what() );
1589	>	return NULL;
1590		}
1591		}
1592		resultobj = PyInt_FromLong((long)result);
#	Line 1515 | Line 1631 | static PyObject *_wrap_delete_objectMap(
1631		try {
1632		delete arg1;
1633
1634	+	}catch (const BossSchedFailure & e) {
1635	+	PyErr_SetString ( SchedulerError, e.what() );
1636	+	return NULL;
1637		}catch (const std::exception& e) {
1638	<	SWIG_exception(SWIG_RuntimeError, e.what());
1638	>	PyErr_SetString ( BossError, e.what() );
1639	>	return NULL;
1640		}
1641		}
1642		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1533 | Line 1653 | static PyObject * objectMap_swigregister
1653		Py_INCREF(obj);
1654		return Py_BuildValue((char *)"");
1655		}
1656	<	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
1656	>	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1657		PyObject *resultobj;
1658	<	BossSession *arg1 = (BossSession *) 0 ;
1659	<	std::vector<std::string > *arg2 = 0 ;
1660	<	PyObject *result;
1658	>	unsigned int arg1 = (unsigned int) 0 ;
1659	>	std::vector<std::string > *result;
1660	>	PyObject * obj0 = 0 ;
1661	>
1662	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1663	>	if (obj0) {
1664	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1665	>	if (PyErr_Occurred()) SWIG_fail;
1666	>	}
1667	>	{
1668	>	try {
1669	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1670	>
1671	>	}catch (const BossSchedFailure & e) {
1672	>	PyErr_SetString ( SchedulerError, e.what() );
1673	>	return NULL;
1674	>	}catch (const std::exception& e) {
1675	>	PyErr_SetString ( BossError, e.what() );
1676	>	return NULL;
1677	>	}
1678	>	}
1679	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1680	>	return resultobj;
1681	>	fail:
1682	>	return NULL;
1683	>	}
1684	>
1685	>
1686	>	static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1687	>	PyObject *resultobj;
1688	>	unsigned int arg1 ;
1689	>	std::string *arg2 = 0 ;
1690	>	std::vector<std::string > *result;
1691	>	std::string temp2 ;
1692		PyObject * obj0 = 0 ;
1693		PyObject * obj1 = 0 ;
1694
1695	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
1696	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1697	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1698	<	if (arg2 == NULL) {
1699	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
1695	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1696	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1697	>	if (PyErr_Occurred()) SWIG_fail;
1698	>	{
1699	>	if (PyString_Check(obj1)) {
1700	>	temp2 = std::string(PyString_AsString(obj1));
1701	>	arg2 = &temp2;
1702	>	}else {
1703	>	SWIG_exception(SWIG_TypeError, "string expected");
1704	>	}
1705		}
1706		{
1707		try {
1708	<	result = (PyObject *)BossSession_show(arg1,*arg2);
1708	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1709
1710	+	}catch (const BossSchedFailure & e) {
1711	+	PyErr_SetString ( SchedulerError, e.what() );
1712	+	return NULL;
1713		}catch (const std::exception& e) {
1714	<	SWIG_exception(SWIG_RuntimeError, e.what());
1714	>	PyErr_SetString ( BossError, e.what() );
1715	>	return NULL;
1716		}
1717		}
1718	<	resultobj = result;
1718	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1719		return resultobj;
1720		fail:
1721		return NULL;
1722		}
1723
1724
1725	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_1(PyObject *self, PyObject *args) {
1725	>	static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1726		PyObject *resultobj;
1727	<	BossSession *arg1 = (BossSession *) 0 ;
1728	<	PyObject *result;
1727	>	std::vector<std::string > *arg1 = 0 ;
1728	>	std::vector<std::string > *result;
1729	>	std::vector<std::string > temp1 ;
1730	>	std::vector<std::string > *v1 ;
1731		PyObject * obj0 = 0 ;
1732
1733	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
1734	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1733	>	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1734	>	{
1735	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1736	>	unsigned int size = (PyTuple_Check(obj0) ?
1737	>	PyTuple_Size(obj0) :
1738	>	PyList_Size(obj0));
1739	>	temp1 = std::vector<std::string >(size);
1740	>	arg1 = &temp1;
1741	>	for (unsigned int i=0; i<size; i++) {
1742	>	PyObject* o = PySequence_GetItem(obj0,i);
1743	>	if (PyString_Check(o)) {
1744	>	temp1[i] = (std::string)(\
1745	>	SwigString_AsString(o));
1746	>	Py_DECREF(o);
1747	>	}else {
1748	>	Py_DECREF(o);
1749	>	PyErr_SetString(PyExc_TypeError,
1750	>	"vector<""std::string""> expected");
1751	>	SWIG_fail;
1752	>	}
1753	>	}
1754	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1755	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1756	>	arg1 = v1;
1757	>	}else {
1758	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1759	>	SWIG_fail;
1760	>	}
1761	>	}
1762		{
1763		try {
1764	<	result = (PyObject *)BossSession_showCHTools__SWIG_1(arg1);
1764	>	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1765
1766	+	}catch (const BossSchedFailure & e) {
1767	+	PyErr_SetString ( SchedulerError, e.what() );
1768	+	return NULL;
1769		}catch (const std::exception& e) {
1770	<	SWIG_exception(SWIG_RuntimeError, e.what());
1770	>	PyErr_SetString ( BossError, e.what() );
1771	>	return NULL;
1772		}
1773		}
1774	<	resultobj = result;
1774	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1775		return resultobj;
1776		fail:
1777		return NULL;
1778		}
1779
1780
1781	<	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
1781	>	static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1782		int argc;
1783	<	PyObject *argv[2];
1783	>	PyObject *argv[3];
1784		int ii;
1785
1786		argc = PyObject_Length(args);
1787	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1787	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1788		argv[ii] = PyTuple_GetItem(args,ii);
1789		}
1790	+	if ((argc >= 0) && (argc <= 1)) {
1791	+	int _v;
1792	+	if (argc <= 0) {
1793	+	return _wrap_new_vector_string__SWIG_0(self,args);
1794	+	}
1795	+	{
1796	+	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1797	+	}
1798	+	if (_v) {
1799	+	return _wrap_new_vector_string__SWIG_0(self,args);
1800	+	}
1801	+	}
1802		if (argc == 1) {
1803		int _v;
1804		{
1805	<	void *ptr;
1806	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1807	<	_v = 0;
1808	<	PyErr_Clear();
1805	>	/* native sequence? */
1806	>	if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1807	>	unsigned int size = (PyTuple_Check(argv[0]) ?
1808	>	PyTuple_Size(argv[0]) :
1809	>	PyList_Size(argv[0]));
1810	>	if (size == 0) {
1811	>	/* an empty sequence can be of any type */
1812	>	_v = 1;
1813	>	}else {
1814	>	/* check the first element only */
1815	>	PyObject* o = PySequence_GetItem(argv[0],0);
1816	>	if (PyString_Check(o))
1817	>	_v = 1;
1818	>	else
1819	>	_v = 0;
1820	>	Py_DECREF(o);
1821	>	}
1822		}else {
1823	+	/* wrapped vector? */
1824	+	std::vector<std::string >* v;
1825	+	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1826	+	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1827		_v = 1;
1828	+	else
1829	+	_v = 0;
1830		}
1831		}
1832		if (_v) {
1833	<	return _wrap_BossSession_showCHTools__SWIG_1(self,args);
1833	>	return _wrap_new_vector_string__SWIG_2(self,args);
1834	>	}
1835	>	}
1836	>	if (argc == 2) {
1837	>	int _v;
1838	>	{
1839	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1840	>	}
1841	>	if (_v) {
1842	>	{
1843	>	_v = PyString_Check(argv[1]) ? 1 : 0;
1844	>	}
1845	>	if (_v) {
1846	>	return _wrap_new_vector_string__SWIG_1(self,args);
1847	>	}
1848		}
1849		}
1850
1851	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showCHTools'");
1851	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1852		return NULL;
1853		}
1854
1855
1856	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_1(PyObject *self, PyObject *args) {
1856	>	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1857		PyObject *resultobj;
1858	<	BossSession *arg1 = (BossSession *) 0 ;
1859	<	PyObject *result;
1858	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1859	>	unsigned int result;
1860	>	std::vector<std::string > temp1 ;
1861	>	std::vector<std::string > *v1 ;
1862		PyObject * obj0 = 0 ;
1863
1864	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
1865	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1864	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1865	>	{
1866	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1867	>	unsigned int size = (PyTuple_Check(obj0) ?
1868	>	PyTuple_Size(obj0) :
1869	>	PyList_Size(obj0));
1870	>	temp1 = std::vector<std::string >(size);
1871	>	arg1 = &temp1;
1872	>	for (unsigned int i=0; i<size; i++) {
1873	>	PyObject* o = PySequence_GetItem(obj0,i);
1874	>	if (PyString_Check(o)) {
1875	>	temp1[i] = (std::string)(\
1876	>	SwigString_AsString(o));
1877	>	Py_DECREF(o);
1878	>	}else {
1879	>	Py_DECREF(o);
1880	>	PyErr_SetString(PyExc_TypeError,
1881	>	"vector<""std::string""> expected");
1882	>	SWIG_fail;
1883	>	}
1884	>	}
1885	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1886	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1887	>	arg1 = v1;
1888	>	}else {
1889	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1890	>	SWIG_fail;
1891	>	}
1892	>	}
1893		{
1894		try {
1895	<	result = (PyObject *)BossSession_showProgramTypes__SWIG_1(arg1);
1895	>	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1896
1897	+	}catch (const BossSchedFailure & e) {
1898	+	PyErr_SetString ( SchedulerError, e.what() );
1899	+	return NULL;
1900		}catch (const std::exception& e) {
1901	<	SWIG_exception(SWIG_RuntimeError, e.what());
1901	>	PyErr_SetString ( BossError, e.what() );
1902	>	return NULL;
1903		}
1904		}
1905	<	resultobj = result;
1905	>	resultobj = PyInt_FromLong((long)result);
1906		return resultobj;
1907		fail:
1908		return NULL;
1909		}
1910
1911
1912	<	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
1913	<	int argc;
1914	<	PyObject *argv[2];
1915	<	int ii;
1912	>	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
1913	>	PyObject *resultobj;
1914	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1915	>	bool result;
1916	>	std::vector<std::string > temp1 ;
1917	>	std::vector<std::string > *v1 ;
1918	>	PyObject * obj0 = 0 ;
1919
1920	<	argc = PyObject_Length(args);
1921	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1922	<	argv[ii] = PyTuple_GetItem(args,ii);
1923	<	}
1924	<	if (argc == 1) {
1925	<	int _v;
1926	<	{
1927	<	void *ptr;
1928	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1929	<	_v = 0;
1930	<	PyErr_Clear();
1931	<	}else {
1932	<	_v = 1;
1920	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
1921	>	{
1922	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1923	>	unsigned int size = (PyTuple_Check(obj0) ?
1924	>	PyTuple_Size(obj0) :
1925	>	PyList_Size(obj0));
1926	>	temp1 = std::vector<std::string >(size);
1927	>	arg1 = &temp1;
1928	>	for (unsigned int i=0; i<size; i++) {
1929	>	PyObject* o = PySequence_GetItem(obj0,i);
1930	>	if (PyString_Check(o)) {
1931	>	temp1[i] = (std::string)(\
1932	>	SwigString_AsString(o));
1933	>	Py_DECREF(o);
1934	>	}else {
1935	>	Py_DECREF(o);
1936	>	PyErr_SetString(PyExc_TypeError,
1937	>	"vector<""std::string""> expected");
1938	>	SWIG_fail;
1939	>	}
1940		}
1941	+	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1942	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1943	+	arg1 = v1;
1944	+	}else {
1945	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1946	+	SWIG_fail;
1947		}
1948	<	if (_v) {
1949	<	return _wrap_BossSession_showProgramTypes__SWIG_1(self,args);
1948	>	}
1949	>	{
1950	>	try {
1951	>	result = (bool)((std::vector<std::string > const *)arg1)->empty();
1952	>
1953	>	}catch (const BossSchedFailure & e) {
1954	>	PyErr_SetString ( SchedulerError, e.what() );
1955	>	return NULL;
1956	>	}catch (const std::exception& e) {
1957	>	PyErr_SetString ( BossError, e.what() );
1958	>	return NULL;
1959		}
1960		}
1961	<
1962	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showProgramTypes'");
1961	>	resultobj = PyInt_FromLong((long)result);
1962	>	return resultobj;
1963	>	fail:
1964		return NULL;
1965		}
1966
1967
1968	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_1(PyObject *self, PyObject *args) {
1968	>	static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
1969		PyObject *resultobj;
1970	<	BossSession *arg1 = (BossSession *) 0 ;
1674	<	PyObject *result;
1970	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1971		PyObject * obj0 = 0 ;
1972
1973	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
1974	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1973	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
1974	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1975		{
1976		try {
1977	<	result = (PyObject *)BossSession_showRTMon__SWIG_1(arg1);
1977	>	(arg1)->clear();
1978
1979	+	}catch (const BossSchedFailure & e) {
1980	+	PyErr_SetString ( SchedulerError, e.what() );
1981	+	return NULL;
1982		}catch (const std::exception& e) {
1983	<	SWIG_exception(SWIG_RuntimeError, e.what());
1983	>	PyErr_SetString ( BossError, e.what() );
1984	>	return NULL;
1985		}
1986		}
1987	<	resultobj = result;
1987	>	Py_INCREF(Py_None); resultobj = Py_None;
1988		return resultobj;
1989		fail:
1990		return NULL;
1991		}
1992
1993
1994	<	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
1995	<	int argc;
1996	<	PyObject *argv[2];
1997	<	int ii;
1994	>	static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
1995	>	PyObject *resultobj;
1996	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1997	>	std::string arg2 ;
1998	>	PyObject * obj0 = 0 ;
1999	>	PyObject * obj1 = 0 ;
2000
2001	<	argc = PyObject_Length(args);
2002	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2003	<	argv[ii] = PyTuple_GetItem(args,ii);
2001	>	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
2002	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2003	>	{
2004	>	if (PyString_Check(obj1))
2005	>	arg2 = std::string(PyString_AsString(obj1));
2006	>	else
2007	>	SWIG_exception(SWIG_TypeError, "string expected");
2008		}
2009	<	if (argc == 1) {
2010	<	int _v;
2011	<	{
2012	<	void *ptr;
2013	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2014	<	_v = 0;
2015	<	PyErr_Clear();
2016	<	}else {
2017	<	_v = 1;
2018	<	}
2009	>	{
2010	>	try {
2011	>	(arg1)->push_back(arg2);
2012	>
2013	>	}catch (const BossSchedFailure & e) {
2014	>	PyErr_SetString ( SchedulerError, e.what() );
2015	>	return NULL;
2016	>	}catch (const std::exception& e) {
2017	>	PyErr_SetString ( BossError, e.what() );
2018	>	return NULL;
2019		}
2020	<	if (_v) {
2021	<	return _wrap_BossSession_showRTMon__SWIG_1(self,args);
2020	>	}
2021	>	Py_INCREF(Py_None); resultobj = Py_None;
2022	>	return resultobj;
2023	>	fail:
2024	>	return NULL;
2025	>	}
2026	>
2027	>
2028	>	static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
2029	>	PyObject *resultobj;
2030	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2031	>	std::string result;
2032	>	PyObject * obj0 = 0 ;
2033	>
2034	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
2035	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2036	>	{
2037	>	try {
2038	>	result = std_vectorlstd_string_g_pop___(arg1);
2039	>
2040	>	}catch (std::out_of_range& e) {
2041	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2042		}
2043		}
2044	+	{
2045	+	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2046	+	}
2047	+	return resultobj;
2048	+	fail:
2049	+	return NULL;
2050	+	}
2051	+
2052	+
2053	+	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
2054	+	PyObject *resultobj;
2055	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2056	+	int arg2 ;
2057	+	std::string result;
2058	+	PyObject * obj0 = 0 ;
2059
2060	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showRTMon'");
2060	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
2061	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2062	>	{
2063	>	try {
2064	>	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
2065	>
2066	>	}catch (std::out_of_range& e) {
2067	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2068	>	}
2069	>	}
2070	>	{
2071	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2072	>	}
2073	>	return resultobj;
2074	>	fail:
2075		return NULL;
2076		}
2077
2078
2079	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_1(PyObject *self, PyObject *args) {
2079	>	static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2080		PyObject *resultobj;
2081	<	BossSession *arg1 = (BossSession *) 0 ;
2082	<	PyObject *result;
2081	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2082	>	int arg2 ;
2083	>	int arg3 ;
2084	>	std::vector<std::string > result;
2085		PyObject * obj0 = 0 ;
2086
2087	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2088	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2087	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2088	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2089		{
2090		try {
2091	<	result = (PyObject *)BossSession_showSchedulers__SWIG_1(arg1);
2091	>	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2092
2093	+	}catch (const BossSchedFailure & e) {
2094	+	PyErr_SetString ( SchedulerError, e.what() );
2095	+	return NULL;
2096		}catch (const std::exception& e) {
2097	<	SWIG_exception(SWIG_RuntimeError, e.what());
2097	>	PyErr_SetString ( BossError, e.what() );
2098	>	return NULL;
2099		}
2100		}
2101	<	resultobj = result;
2101	>	{
2102	>	resultobj = PyTuple_New((&result)->size());
2103	>	for (unsigned int i=0; i<(&result)->size(); i++)
2104	>	PyTuple_SetItem(resultobj,i,
2105	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2106	>	}
2107		return resultobj;
2108		fail:
2109		return NULL;
2110		}
2111
2112
2113	<	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2114	<	int argc;
2115	<	PyObject *argv[2];
2116	<	int ii;
2113	>	static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2114	>	PyObject *resultobj;
2115	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2116	>	int arg2 ;
2117	>	std::string arg3 ;
2118	>	PyObject * obj0 = 0 ;
2119	>	PyObject * obj2 = 0 ;
2120
2121	<	argc = PyObject_Length(args);
2122	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2123	<	argv[ii] = PyTuple_GetItem(args,ii);
2121	>	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2122	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2123	>	{
2124	>	if (PyString_Check(obj2))
2125	>	arg3 = std::string(PyString_AsString(obj2));
2126	>	else
2127	>	SWIG_exception(SWIG_TypeError, "string expected");
2128		}
2129	<	if (argc == 1) {
2130	<	int _v;
2131	<	{
2132	<	void *ptr;
2133	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2134	<	_v = 0;
1762	<	PyErr_Clear();
1763	<	}else {
1764	<	_v = 1;
1765	<	}
1766	<	}
1767	<	if (_v) {
1768	<	return _wrap_BossSession_showSchedulers__SWIG_1(self,args);
2129	>	{
2130	>	try {
2131	>	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2132	>
2133	>	}catch (std::out_of_range& e) {
2134	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2135		}
2136		}
2137	<
2138	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showSchedulers'");
2137	>	Py_INCREF(Py_None); resultobj = Py_None;
2138	>	return resultobj;
2139	>	fail:
2140		return NULL;
2141		}
2142
2143
2144	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
2144	>	static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2145		PyObject *resultobj;
2146	<	BossSession *arg1 = (BossSession *) 0 ;
2147	<	int arg2 = (int) SCHEDULED ;
2148	<	std::string const &arg3_defvalue = "all" ;
2149	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
2150	<	std::string const &arg4_defvalue = "all" ;
2151	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
1785	<	std::string const &arg5_defvalue = "" ;
1786	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
1787	<	std::string arg6 = (std::string) "" ;
1788	<	std::string arg7 = (std::string) "" ;
1789	<	std::string arg8 = (std::string) "" ;
1790	<	std::string arg9 = (std::string) "" ;
1791	<	bool arg10 = (bool) false ;
1792	<	PyObject *result;
1793	<	std::string temp3 ;
1794	<	std::string temp4 ;
1795	<	std::string temp5 ;
2146	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2147	>	int arg2 ;
2148	>	int arg3 ;
2149	>	std::vector<std::string > *arg4 = 0 ;
2150	>	std::vector<std::string > temp4 ;
2151	>	std::vector<std::string > *v4 ;
2152		PyObject * obj0 = 0 ;
1797	–	PyObject * obj2 = 0 ;
2153		PyObject * obj3 = 0 ;
1799	–	PyObject * obj4 = 0 ;
1800	–	PyObject * obj5 = 0 ;
1801	–	PyObject * obj6 = 0 ;
1802	–	PyObject * obj7 = 0 ;
1803	–	PyObject * obj8 = 0 ;
1804	–	PyObject * obj9 = 0 ;
2154
2155	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2156	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2157	<	if (obj2) {
2158	<	{
2159	<	if (PyString_Check(obj2)) {
2160	<	temp3 = std::string(PyString_AsString(obj2));
2161	<	arg3 = &temp3;
2162	<	}else {
2163	<	SWIG_exception(SWIG_TypeError, "string expected");
2155	>	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2156	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2157	>	{
2158	>	if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2159	>	unsigned int size = (PyTuple_Check(obj3) ?
2160	>	PyTuple_Size(obj3) :
2161	>	PyList_Size(obj3));
2162	>	temp4 = std::vector<std::string >(size);
2163	>	arg4 = &temp4;
2164	>	for (unsigned int i=0; i<size; i++) {
2165	>	PyObject* o = PySequence_GetItem(obj3,i);
2166	>	if (PyString_Check(o)) {
2167	>	temp4[i] = (std::string)(\
2168	>	SwigString_AsString(o));
2169	>	Py_DECREF(o);
2170	>	}else {
2171	>	Py_DECREF(o);
2172	>	PyErr_SetString(PyExc_TypeError,
2173	>	"vector<""std::string""> expected");
2174	>	SWIG_fail;
2175	>	}
2176		}
2177	+	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2178	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2179	+	arg4 = v4;
2180	+	}else {
2181	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2182	+	SWIG_fail;
2183		}
2184		}
2185	<	if (obj3) {
2186	<	{
2187	<	if (PyString_Check(obj3)) {
2188	<	temp4 = std::string(PyString_AsString(obj3));
2189	<	arg4 = &temp4;
2190	<	}else {
2191	<	SWIG_exception(SWIG_TypeError, "string expected");
2192	<	}
2185	>	{
2186	>	try {
2187	>	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2188	>
2189	>	}catch (const BossSchedFailure & e) {
2190	>	PyErr_SetString ( SchedulerError, e.what() );
2191	>	return NULL;
2192	>	}catch (const std::exception& e) {
2193	>	PyErr_SetString ( BossError, e.what() );
2194	>	return NULL;
2195		}
2196		}
2197	<	if (obj4) {
2198	<	{
2199	<	if (PyString_Check(obj4)) {
2200	<	temp5 = std::string(PyString_AsString(obj4));
2201	<	arg5 = &temp5;
2202	<	}else {
2203	<	SWIG_exception(SWIG_TypeError, "string expected");
2204	<	}
2197	>	Py_INCREF(Py_None); resultobj = Py_None;
2198	>	return resultobj;
2199	>	fail:
2200	>	return NULL;
2201	>	}
2202	>
2203	>
2204	>	static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2205	>	PyObject *resultobj;
2206	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2207	>	int arg2 ;
2208	>	PyObject * obj0 = 0 ;
2209	>
2210	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2211	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2212	>	{
2213	>	try {
2214	>	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2215	>
2216	>	}catch (std::out_of_range& e) {
2217	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2218		}
2219		}
2220	<	if (obj5) {
2220	>	Py_INCREF(Py_None); resultobj = Py_None;
2221	>	return resultobj;
2222	>	fail:
2223	>	return NULL;
2224	>	}
2225	>
2226	>
2227	>	static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2228	>	PyObject *resultobj;
2229	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2230	>	int arg2 ;
2231	>	int arg3 ;
2232	>	PyObject * obj0 = 0 ;
2233	>
2234	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2235	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2236	>	{
2237	>	try {
2238	>	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2239	>
2240	>	}catch (const BossSchedFailure & e) {
2241	>	PyErr_SetString ( SchedulerError, e.what() );
2242	>	return NULL;
2243	>	}catch (const std::exception& e) {
2244	>	PyErr_SetString ( BossError, e.what() );
2245	>	return NULL;
2246	>	}
2247	>	}
2248	>	Py_INCREF(Py_None); resultobj = Py_None;
2249	>	return resultobj;
2250	>	fail:
2251	>	return NULL;
2252	>	}
2253	>
2254	>
2255	>	static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2256	>	PyObject *resultobj;
2257	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2258	>	PyObject * obj0 = 0 ;
2259	>
2260	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2261	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2262	>	{
2263	>	try {
2264	>	delete arg1;
2265	>
2266	>	}catch (const BossSchedFailure & e) {
2267	>	PyErr_SetString ( SchedulerError, e.what() );
2268	>	return NULL;
2269	>	}catch (const std::exception& e) {
2270	>	PyErr_SetString ( BossError, e.what() );
2271	>	return NULL;
2272	>	}
2273	>	}
2274	>	Py_INCREF(Py_None); resultobj = Py_None;
2275	>	return resultobj;
2276	>	fail:
2277	>	return NULL;
2278	>	}
2279	>
2280	>
2281	>	static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2282	>	PyObject *obj;
2283	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2284	>	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2285	>	Py_INCREF(obj);
2286	>	return Py_BuildValue((char *)"");
2287	>	}
2288	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2289	>	PyObject *resultobj;
2290	>	std::string arg1 = (std::string) "" ;
2291	>	std::string arg2 = (std::string) "2" ;
2292	>	std::string arg3 = (std::string) "" ;
2293	>	std::string arg4 = (std::string) "" ;
2294	>	BossSession *result;
2295	>	PyObject * obj0 = 0 ;
2296	>	PyObject * obj1 = 0 ;
2297	>	PyObject * obj2 = 0 ;
2298	>	PyObject * obj3 = 0 ;
2299	>
2300	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2301	>	if (obj0) {
2302		{
2303	<	if (PyString_Check(obj5))
2304	<	arg6 = std::string(PyString_AsString(obj5));
2303	>	if (PyString_Check(obj0))
2304	>	arg1 = std::string(PyString_AsString(obj0));
2305		else
2306		SWIG_exception(SWIG_TypeError, "string expected");
2307		}
2308		}
2309	<	if (obj6) {
2309	>	if (obj1) {
2310		{
2311	<	if (PyString_Check(obj6))
2312	<	arg7 = std::string(PyString_AsString(obj6));
2311	>	if (PyString_Check(obj1))
2312	>	arg2 = std::string(PyString_AsString(obj1));
2313		else
2314		SWIG_exception(SWIG_TypeError, "string expected");
2315		}
2316		}
2317	<	if (obj7) {
2317	>	if (obj2) {
2318		{
2319	<	if (PyString_Check(obj7))
2320	<	arg8 = std::string(PyString_AsString(obj7));
2319	>	if (PyString_Check(obj2))
2320	>	arg3 = std::string(PyString_AsString(obj2));
2321		else
2322		SWIG_exception(SWIG_TypeError, "string expected");
2323		}
2324		}
2325	<	if (obj8) {
2325	>	if (obj3) {
2326		{
2327	<	if (PyString_Check(obj8))
2328	<	arg9 = std::string(PyString_AsString(obj8));
2327	>	if (PyString_Check(obj3))
2328	>	arg4 = std::string(PyString_AsString(obj3));
2329		else
2330		SWIG_exception(SWIG_TypeError, "string expected");
2331		}
2332		}
1870	–	if (obj9) {
1871	–	arg10 = PyInt_AsLong(obj9) ? true : false;
1872	–	if (PyErr_Occurred()) SWIG_fail;
1873	–	}
2333		{
2334		try {
2335	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2335	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2336
2337	+	}catch (const BossSchedFailure & e) {
2338	+	PyErr_SetString ( SchedulerError, e.what() );
2339	+	return NULL;
2340		}catch (const std::exception& e) {
2341	<	SWIG_exception(SWIG_RuntimeError, e.what());
2341	>	PyErr_SetString ( BossError, e.what() );
2342	>	return NULL;
2343		}
2344		}
2345	<	resultobj = result;
2345	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2346		return resultobj;
2347		fail:
2348		return NULL;
2349		}
2350
2351
2352	<	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2352	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2353		PyObject *resultobj;
2354	<	std::string arg1 = (std::string) "" ;
1892	<	BossSession *result;
2354	>	BossSession *arg1 = (BossSession *) 0 ;
2355		PyObject * obj0 = 0 ;
2356
2357	<	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2358	<	if (obj0) {
2359	<	{
2360	<	if (PyString_Check(obj0))
2361	<	arg1 = std::string(PyString_AsString(obj0));
2362	<	else
2363	<	SWIG_exception(SWIG_TypeError, "string expected");
2357	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2358	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2359	>	{
2360	>	try {
2361	>	delete arg1;
2362	>
2363	>	}catch (const BossSchedFailure & e) {
2364	>	PyErr_SetString ( SchedulerError, e.what() );
2365	>	return NULL;
2366	>	}catch (const std::exception& e) {
2367	>	PyErr_SetString ( BossError, e.what() );
2368	>	return NULL;
2369		}
2370		}
2371	+	Py_INCREF(Py_None); resultobj = Py_None;
2372	+	return resultobj;
2373	+	fail:
2374	+	return NULL;
2375	+	}
2376	+
2377	+
2378	+	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2379	+	PyObject *resultobj;
2380	+	BossSession *arg1 = (BossSession *) 0 ;
2381	+	PyObject * obj0 = 0 ;
2382	+
2383	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2384	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2385		{
2386		try {
2387	<	result = (BossSession *)new BossSession(arg1);
2387	>	(arg1)->resetDB();
2388
2389	+	}catch (const BossSchedFailure & e) {
2390	+	PyErr_SetString ( SchedulerError, e.what() );
2391	+	return NULL;
2392		}catch (const std::exception& e) {
2393	<	SWIG_exception(SWIG_RuntimeError, e.what());
2393	>	PyErr_SetString ( BossError, e.what() );
2394	>	return NULL;
2395		}
2396		}
2397	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2397	>	Py_INCREF(Py_None); resultobj = Py_None;
2398		return resultobj;
2399		fail:
2400		return NULL;
2401		}
2402
2403
2404	<	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2404	>	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2405		PyObject *resultobj;
2406		BossSession *arg1 = (BossSession *) 0 ;
2407		PyObject * obj0 = 0 ;
2408
2409	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2409	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2410		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2411		{
2412		try {
2413	<	delete arg1;
2413	>	(arg1)->clear();
2414
2415	+	}catch (const BossSchedFailure & e) {
2416	+	PyErr_SetString ( SchedulerError, e.what() );
2417	+	return NULL;
2418		}catch (const std::exception& e) {
2419	<	SWIG_exception(SWIG_RuntimeError, e.what());
2419	>	PyErr_SetString ( BossError, e.what() );
2420	>	return NULL;
2421		}
2422		}
2423		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1964 | Line 2453 | static PyObject *_wrap_BossSession_makeB
2453		try {
2454		result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2455
2456	+	}catch (const BossSchedFailure & e) {
2457	+	PyErr_SetString ( SchedulerError, e.what() );
2458	+	return NULL;
2459		}catch (const std::exception& e) {
2460	<	SWIG_exception(SWIG_RuntimeError, e.what());
2460	>	PyErr_SetString ( BossError, e.what() );
2461	>	return NULL;
2462		}
2463		}
2464		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
#	Line 1989 | Line 2482 | static PyObject *_wrap_BossSession_destr
2482		try {
2483		(arg1)->destroyBossTask(arg2);
2484
2485	+	}catch (const BossSchedFailure & e) {
2486	+	PyErr_SetString ( SchedulerError, e.what() );
2487	+	return NULL;
2488		}catch (const std::exception& e) {
2489	<	SWIG_exception(SWIG_RuntimeError, e.what());
2489	>	PyErr_SetString ( BossError, e.what() );
2490	>	return NULL;
2491		}
2492		}
2493		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2000 | Line 2497 | static PyObject *_wrap_BossSession_destr
2497		}
2498
2499
2500	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_0(PyObject *self, PyObject *args) {
2500	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2501		PyObject *resultobj;
2502		BossSession *arg1 = (BossSession *) 0 ;
2503	<	SwigValueWrapper< std::vector<std::string > > result;
2503	>	std::vector<std::string > result;
2504		PyObject * obj0 = 0 ;
2505
2506		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
#	Line 2012 | Line 2509 | static PyObject *_wrap_BossSession_showC
2509		try {
2510		result = (arg1)->showCHTools();
2511
2512	+	}catch (const BossSchedFailure & e) {
2513	+	PyErr_SetString ( SchedulerError, e.what() );
2514	+	return NULL;
2515		}catch (const std::exception& e) {
2516	<	SWIG_exception(SWIG_RuntimeError, e.what());
2516	>	PyErr_SetString ( BossError, e.what() );
2517	>	return NULL;
2518		}
2519		}
2520		{
2521	<	std::vector<std::string > * resultptr;
2522	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2523	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2521	>	resultobj = PyTuple_New((&result)->size());
2522	>	for (unsigned int i=0; i<(&result)->size(); i++)
2523	>	PyTuple_SetItem(resultobj,i,
2524	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2525		}
2526		return resultobj;
2527		fail:
#	Line 2027 | Line 2529 | static PyObject *_wrap_BossSession_showC
2529		}
2530
2531
2532	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_0(PyObject *self, PyObject *args) {
2532	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2533		PyObject *resultobj;
2534		BossSession *arg1 = (BossSession *) 0 ;
2535	<	SwigValueWrapper< std::vector<std::string > > result;
2535	>	std::vector<std::string > result;
2536		PyObject * obj0 = 0 ;
2537
2538		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
#	Line 2039 | Line 2541 | static PyObject *_wrap_BossSession_showP
2541		try {
2542		result = (arg1)->showProgramTypes();
2543
2544	+	}catch (const BossSchedFailure & e) {
2545	+	PyErr_SetString ( SchedulerError, e.what() );
2546	+	return NULL;
2547		}catch (const std::exception& e) {
2548	<	SWIG_exception(SWIG_RuntimeError, e.what());
2548	>	PyErr_SetString ( BossError, e.what() );
2549	>	return NULL;
2550		}
2551		}
2552		{
2553	<	std::vector<std::string > * resultptr;
2554	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2555	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2553	>	resultobj = PyTuple_New((&result)->size());
2554	>	for (unsigned int i=0; i<(&result)->size(); i++)
2555	>	PyTuple_SetItem(resultobj,i,
2556	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2557		}
2558		return resultobj;
2559		fail:
#	Line 2054 | Line 2561 | static PyObject *_wrap_BossSession_showP
2561		}
2562
2563
2564	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_0(PyObject *self, PyObject *args) {
2564	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2565		PyObject *resultobj;
2566		BossSession *arg1 = (BossSession *) 0 ;
2567	<	SwigValueWrapper< std::vector<std::string > > result;
2567	>	std::vector<std::string > result;
2568		PyObject * obj0 = 0 ;
2569
2570		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
#	Line 2066 | Line 2573 | static PyObject *_wrap_BossSession_showR
2573		try {
2574		result = (arg1)->showRTMon();
2575
2576	+	}catch (const BossSchedFailure & e) {
2577	+	PyErr_SetString ( SchedulerError, e.what() );
2578	+	return NULL;
2579		}catch (const std::exception& e) {
2580	<	SWIG_exception(SWIG_RuntimeError, e.what());
2580	>	PyErr_SetString ( BossError, e.what() );
2581	>	return NULL;
2582		}
2583		}
2584		{
2585	<	std::vector<std::string > * resultptr;
2586	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2587	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2585	>	resultobj = PyTuple_New((&result)->size());
2586	>	for (unsigned int i=0; i<(&result)->size(); i++)
2587	>	PyTuple_SetItem(resultobj,i,
2588	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2589		}
2590		return resultobj;
2591		fail:
#	Line 2081 | Line 2593 | static PyObject *_wrap_BossSession_showR
2593		}
2594
2595
2596	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_0(PyObject *self, PyObject *args) {
2596	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2597		PyObject *resultobj;
2598		BossSession *arg1 = (BossSession *) 0 ;
2599	<	SwigValueWrapper< std::vector<std::string > > result;
2599	>	std::vector<std::string > result;
2600		PyObject * obj0 = 0 ;
2601
2602		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
#	Line 2093 | Line 2605 | static PyObject *_wrap_BossSession_showS
2605		try {
2606		result = (arg1)->showSchedulers();
2607
2608	+	}catch (const BossSchedFailure & e) {
2609	+	PyErr_SetString ( SchedulerError, e.what() );
2610	+	return NULL;
2611		}catch (const std::exception& e) {
2612	<	SWIG_exception(SWIG_RuntimeError, e.what());
2612	>	PyErr_SetString ( BossError, e.what() );
2613	>	return NULL;
2614		}
2615		}
2616		{
2617	<	std::vector<std::string > * resultptr;
2618	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2619	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2617	>	resultobj = PyTuple_New((&result)->size());
2618	>	for (unsigned int i=0; i<(&result)->size(); i++)
2619	>	PyTuple_SetItem(resultobj,i,
2620	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2621		}
2622		return resultobj;
2623		fail:
#	Line 2120 | Line 2637 | static PyObject *_wrap_BossSession_defau
2637		try {
2638		result = (arg1)->defaultCHTool();
2639
2640	+	}catch (const BossSchedFailure & e) {
2641	+	PyErr_SetString ( SchedulerError, e.what() );
2642	+	return NULL;
2643		}catch (const std::exception& e) {
2644	<	SWIG_exception(SWIG_RuntimeError, e.what());
2644	>	PyErr_SetString ( BossError, e.what() );
2645	>	return NULL;
2646		}
2647		}
2648		{
#	Line 2145 | Line 2666 | static PyObject *_wrap_BossSession_defau
2666		try {
2667		result = (arg1)->defaultProgramType();
2668
2669	+	}catch (const BossSchedFailure & e) {
2670	+	PyErr_SetString ( SchedulerError, e.what() );
2671	+	return NULL;
2672		}catch (const std::exception& e) {
2673	<	SWIG_exception(SWIG_RuntimeError, e.what());
2673	>	PyErr_SetString ( BossError, e.what() );
2674	>	return NULL;
2675		}
2676		}
2677		{
#	Line 2170 | Line 2695 | static PyObject *_wrap_BossSession_defau
2695		try {
2696		result = (arg1)->defaultRTMon();
2697
2698	+	}catch (const BossSchedFailure & e) {
2699	+	PyErr_SetString ( SchedulerError, e.what() );
2700	+	return NULL;
2701		}catch (const std::exception& e) {
2702	<	SWIG_exception(SWIG_RuntimeError, e.what());
2702	>	PyErr_SetString ( BossError, e.what() );
2703	>	return NULL;
2704		}
2705		}
2706		{
#	Line 2195 | Line 2724 | static PyObject *_wrap_BossSession_defau
2724		try {
2725		result = (arg1)->defaultScheduler();
2726
2727	+	}catch (const BossSchedFailure & e) {
2728	+	PyErr_SetString ( SchedulerError, e.what() );
2729	+	return NULL;
2730		}catch (const std::exception& e) {
2731	<	SWIG_exception(SWIG_RuntimeError, e.what());
2731	>	PyErr_SetString ( BossError, e.what() );
2732	>	return NULL;
2733		}
2734		}
2735		{
#	Line 2220 | Line 2753 | static PyObject *_wrap_BossSession_versi
2753		try {
2754		result = (arg1)->version();
2755
2756	+	}catch (const BossSchedFailure & e) {
2757	+	PyErr_SetString ( SchedulerError, e.what() );
2758	+	return NULL;
2759		}catch (const std::exception& e) {
2760	<	SWIG_exception(SWIG_RuntimeError, e.what());
2760	>	PyErr_SetString ( BossError, e.what() );
2761	>	return NULL;
2762		}
2763		}
2764		{
#	Line 2245 | Line 2782 | static PyObject *_wrap_BossSession_clien
2782		try {
2783		result = (arg1)->clientID();
2784
2785	+	}catch (const BossSchedFailure & e) {
2786	+	PyErr_SetString ( SchedulerError, e.what() );
2787	+	return NULL;
2788		}catch (const std::exception& e) {
2789	<	SWIG_exception(SWIG_RuntimeError, e.what());
2789	>	PyErr_SetString ( BossError, e.what() );
2790	>	return NULL;
2791		}
2792		}
2793		{
#	Line 2276 | Line 2817 | static PyObject *_wrap_BossSession_showC
2817		try {
2818		result = (int)(arg1)->showConfigs(arg2);
2819
2820	+	}catch (const BossSchedFailure & e) {
2821	+	PyErr_SetString ( SchedulerError, e.what() );
2822	+	return NULL;
2823		}catch (const std::exception& e) {
2824	<	SWIG_exception(SWIG_RuntimeError, e.what());
2825	<	}
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	<
2349	<	}catch (const std::exception& e) {
2350	<	SWIG_exception(SWIG_RuntimeError, e.what());
2824	>	PyErr_SetString ( BossError, e.what() );
2825	>	return NULL;
2826		}
2827		}
2828		resultobj = PyInt_FromLong((long)result);
#	Line 2399 | Line 2874 | static PyObject *_wrap_BossSession_RTupd
2874		try {
2875		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2876
2877	+	}catch (const BossSchedFailure & e) {
2878	+	PyErr_SetString ( SchedulerError, e.what() );
2879	+	return NULL;
2880		}catch (const std::exception& e) {
2881	<	SWIG_exception(SWIG_RuntimeError, e.what());
2881	>	PyErr_SetString ( BossError, e.what() );
2882	>	return NULL;
2883		}
2884		}
2885		resultobj = PyInt_FromLong((long)result);
#	Line 2420 | Line 2899 | static PyObject *_wrap_BossSession_listM
2899		std::string *arg5 = (std::string *) &arg5_defvalue ;
2900		std::string const &arg6_defvalue = "" ;
2901		std::string *arg6 = (std::string *) &arg6_defvalue ;
2902	<	std::string result;
2902	>	std::vector<std::string > result;
2903		std::string temp2 ;
2904		std::string temp3 ;
2905		std::string temp5 ;
#	Line 2478 | Line 2957 | static PyObject *_wrap_BossSession_listM
2957		try {
2958		result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
2959
2960	+	}catch (const BossSchedFailure & e) {
2961	+	PyErr_SetString ( SchedulerError, e.what() );
2962	+	return NULL;
2963		}catch (const std::exception& e) {
2964	<	SWIG_exception(SWIG_RuntimeError, e.what());
2964	>	PyErr_SetString ( BossError, e.what() );
2965	>	return NULL;
2966		}
2967		}
2968		{
2969	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2969	>	resultobj = PyTuple_New((&result)->size());
2970	>	for (unsigned int i=0; i<(&result)->size(); i++)
2971	>	PyTuple_SetItem(resultobj,i,
2972	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2973		}
2974		return resultobj;
2975		fail:
#	Line 2491 | Line 2977 | static PyObject *_wrap_BossSession_listM
2977		}
2978
2979
2980	<	static PyObject *_wrap_BossSession_jobQuery(PyObject *self, PyObject *args) {
2980	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
2981		PyObject *resultobj;
2982		BossSession *arg1 = (BossSession *) 0 ;
2983		int arg2 = (int) SCHEDULED ;
#	Line 2505 | Line 2991 | static PyObject *_wrap_BossSession_jobQu
2991		std::string arg7 = (std::string) "" ;
2992		std::string arg8 = (std::string) "" ;
2993		std::string arg9 = (std::string) "" ;
2508	–	bool arg10 = (bool) false ;
2509	–	SwigValueWrapper< std::vector<BossJob * > > result;
2994		std::string temp3 ;
2995		std::string temp4 ;
2996		std::string temp5 ;
#	Line 2518 | Line 3002 | static PyObject *_wrap_BossSession_jobQu
3002		PyObject * obj6 = 0 ;
3003		PyObject * obj7 = 0 ;
3004		PyObject * obj8 = 0 ;
2521	–	PyObject * obj9 = 0 ;
3005
3006	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_jobQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3006	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3007		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3008		if (obj2) {
3009		{
#	Line 2584 | Line 3067 | static PyObject *_wrap_BossSession_jobQu
3067		SWIG_exception(SWIG_TypeError, "string expected");
3068		}
3069		}
2587	–	if (obj9) {
2588	–	arg10 = PyInt_AsLong(obj9) ? true : false;
2589	–	if (PyErr_Occurred()) SWIG_fail;
2590	–	}
3070		{
3071		try {
3072	<	result = (arg1)->jobQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3072	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3073
3074	+	}catch (const BossSchedFailure & e) {
3075	+	PyErr_SetString ( SchedulerError, e.what() );
3076	+	return NULL;
3077		}catch (const std::exception& e) {
3078	<	SWIG_exception(SWIG_RuntimeError, e.what());
3078	>	PyErr_SetString ( BossError, e.what() );
3079	>	return NULL;
3080		}
3081		}
3082	<	{
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	<	}
3082	>	Py_INCREF(Py_None); resultobj = Py_None;
3083		return resultobj;
3084		fail:
3085		return NULL;
3086		}
3087
3088
3089	<	static PyObject *_wrap_BossSession_queryPrint(PyObject *self, PyObject *args) {
3089	>	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3090		PyObject *resultobj;
3091		BossSession *arg1 = (BossSession *) 0 ;
3092	<	SwigValueWrapper< std::vector<BossJob * > > arg2 ;
3093	<	std::ostream &arg3_defvalue = std::cout ;
3094	<	std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
3095	<	jobStates const &arg4_defvalue = SCHEDULED ;
3096	<	jobStates *arg4 = (jobStates *) &arg4_defvalue ;
3097	<	printOption const &arg5_defvalue = NORMAL ;
3098	<	printOption *arg5 = (printOption *) &arg5_defvalue ;
3099	<	std::string const &arg6_defvalue = "" ;
3100	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
3101	<	std::vector<BossJob * > *argp2 ;
3102	<	std::string temp6 ;
3092	>	std::string const &arg2_defvalue = "all" ;
3093	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3094	>	std::string const &arg3_defvalue = "" ;
3095	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3096	>	std::string const &arg4_defvalue = "" ;
3097	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3098	>	std::string const &arg5_defvalue = "" ;
3099	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3100	>	std::vector<std::string > result;
3101	>	std::string temp2 ;
3102	>	std::string temp3 ;
3103	>	std::string temp4 ;
3104	>	std::string temp5 ;
3105		PyObject * obj0 = 0 ;
3106		PyObject * obj1 = 0 ;
3107		PyObject * obj2 = 0 ;
3108		PyObject * obj3 = 0 ;
3109		PyObject * obj4 = 0 ;
2629	–	PyObject * obj5 = 0 ;
3110
3111	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossSession_queryPrint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3111	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3112		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3113	<	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3114	<	arg2 = *argp2;
3113	>	if (obj1) {
3114	>	{
3115	>	if (PyString_Check(obj1)) {
3116	>	temp2 = std::string(PyString_AsString(obj1));
3117	>	arg2 = &temp2;
3118	>	}else {
3119	>	SWIG_exception(SWIG_TypeError, "string expected");
3120	>	}
3121	>	}
3122	>	}
3123		if (obj2) {
3124	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3125	<	if (arg3 == NULL) {
3126	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3124	>	{
3125	>	if (PyString_Check(obj2)) {
3126	>	temp3 = std::string(PyString_AsString(obj2));
3127	>	arg3 = &temp3;
3128	>	}else {
3129	>	SWIG_exception(SWIG_TypeError, "string expected");
3130	>	}
3131		}
3132		}
3133		if (obj3) {
3134	<	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3135	<	if (arg4 == NULL) {
3136	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3134	>	{
3135	>	if (PyString_Check(obj3)) {
3136	>	temp4 = std::string(PyString_AsString(obj3));
3137	>	arg4 = &temp4;
3138	>	}else {
3139	>	SWIG_exception(SWIG_TypeError, "string expected");
3140	>	}
3141		}
3142		}
3143		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) {
3144		{
3145	<	if (PyString_Check(obj5)) {
3146	<	temp6 = std::string(PyString_AsString(obj5));
3147	<	arg6 = &temp6;
3145	>	if (PyString_Check(obj4)) {
3146	>	temp5 = std::string(PyString_AsString(obj4));
3147	>	arg5 = &temp5;
3148		}else {
3149		SWIG_exception(SWIG_TypeError, "string expected");
3150		}
#	Line 2662 | Line 3152 | static PyObject *_wrap_BossSession_query
3152		}
3153		{
3154		try {
3155	<	(arg1)->queryPrint(arg2,*arg3,(jobStates const &)*arg4,(printOption const &)*arg5,(std::string const &)*arg6);
3155	>	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3156
3157	+	}catch (const BossSchedFailure & e) {
3158	+	PyErr_SetString ( SchedulerError, e.what() );
3159	+	return NULL;
3160		}catch (const std::exception& e) {
3161	<	SWIG_exception(SWIG_RuntimeError, e.what());
3161	>	PyErr_SetString ( BossError, e.what() );
3162	>	return NULL;
3163		}
3164		}
3165	<	Py_INCREF(Py_None); resultobj = Py_None;
3165	>	{
3166	>	resultobj = PyTuple_New((&result)->size());
3167	>	for (unsigned int i=0; i<(&result)->size(); i++)
3168	>	PyTuple_SetItem(resultobj,i,
3169	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3170	>	}
3171		return resultobj;
3172		fail:
3173		return NULL;
3174		}
3175
3176
3177	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3177	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3178		PyObject *resultobj;
3179		BossSession *arg1 = (BossSession *) 0 ;
3180	<	std::string const &arg2_defvalue = "all" ;
3181	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
2683	<	std::string const &arg3_defvalue = "" ;
3180	>	int arg2 = (int) SCHEDULED ;
3181	>	std::string const &arg3_defvalue = "all" ;
3182		std::string *arg3 = (std::string *) &arg3_defvalue ;
3183	<	std::string const &arg4_defvalue = "" ;
3183	>	std::string const &arg4_defvalue = "all" ;
3184		std::string *arg4 = (std::string *) &arg4_defvalue ;
3185		std::string const &arg5_defvalue = "" ;
3186		std::string *arg5 = (std::string *) &arg5_defvalue ;
3187	<	SwigValueWrapper< std::vector<std::string > > result;
3188	<	std::string temp2 ;
3187	>	std::string arg6 = (std::string) "" ;
3188	>	std::string arg7 = (std::string) "" ;
3189	>	std::string arg8 = (std::string) "" ;
3190	>	std::string arg9 = (std::string) "" ;
3191	>	bool arg10 = (bool) false ;
3192	>	SwigValueWrapper< std::vector<BossTask * > > result;
3193		std::string temp3 ;
3194		std::string temp4 ;
3195		std::string temp5 ;
3196		PyObject * obj0 = 0 ;
2695	–	PyObject * obj1 = 0 ;
3197		PyObject * obj2 = 0 ;
3198		PyObject * obj3 = 0 ;
3199		PyObject * obj4 = 0 ;
3200	+	PyObject * obj5 = 0 ;
3201	+	PyObject * obj6 = 0 ;
3202	+	PyObject * obj7 = 0 ;
3203	+	PyObject * obj8 = 0 ;
3204	+	PyObject * obj9 = 0 ;
3205
3206	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3206	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3207		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	–	}
3208		if (obj2) {
3209		{
3210		if (PyString_Check(obj2)) {
#	Line 2739 | Line 3235 | static PyObject *_wrap_BossSession_selec
3235		}
3236		}
3237		}
3238	+	if (obj5) {
3239	+	{
3240	+	if (PyString_Check(obj5))
3241	+	arg6 = std::string(PyString_AsString(obj5));
3242	+	else
3243	+	SWIG_exception(SWIG_TypeError, "string expected");
3244	+	}
3245	+	}
3246	+	if (obj6) {
3247	+	{
3248	+	if (PyString_Check(obj6))
3249	+	arg7 = std::string(PyString_AsString(obj6));
3250	+	else
3251	+	SWIG_exception(SWIG_TypeError, "string expected");
3252	+	}
3253	+	}
3254	+	if (obj7) {
3255	+	{
3256	+	if (PyString_Check(obj7))
3257	+	arg8 = std::string(PyString_AsString(obj7));
3258	+	else
3259	+	SWIG_exception(SWIG_TypeError, "string expected");
3260	+	}
3261	+	}
3262	+	if (obj8) {
3263	+	{
3264	+	if (PyString_Check(obj8))
3265	+	arg9 = std::string(PyString_AsString(obj8));
3266	+	else
3267	+	SWIG_exception(SWIG_TypeError, "string expected");
3268	+	}
3269	+	}
3270	+	if (obj9) {
3271	+	arg10 = PyInt_AsLong(obj9) ? true : false;
3272	+	if (PyErr_Occurred()) SWIG_fail;
3273	+	}
3274		{
3275		try {
3276	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3276	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3277
3278	+	}catch (const BossSchedFailure & e) {
3279	+	PyErr_SetString ( SchedulerError, e.what() );
3280	+	return NULL;
3281		}catch (const std::exception& e) {
3282	<	SWIG_exception(SWIG_RuntimeError, e.what());
3282	>	PyErr_SetString ( BossError, e.what() );
3283	>	return NULL;
3284		}
3285		}
3286		{
3287	<	std::vector<std::string > * resultptr;
3288	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
3289	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
3287	>	std::vector<BossTask * > * resultptr;
3288	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3289	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3290		}
3291		return resultobj;
3292		fail:
#	Line 2758 | Line 3294 | static PyObject *_wrap_BossSession_selec
3294		}
3295
3296
3297	<	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
2762	<	PyObject *obj;
2763	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2764	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
2765	<	Py_INCREF(obj);
2766	<	return Py_BuildValue((char *)"");
2767	<	}
2768	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3297	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3298		PyObject *resultobj;
3299	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3300	<	char *arg2 ;
3299	>	BossSession *arg1 = (BossSession *) 0 ;
3300	>	std::vector<std::string > *arg2 = 0 ;
3301	>	PyObject *result;
3302		PyObject * obj0 = 0 ;
3303	+	PyObject * obj1 = 0 ;
3304
3305	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3306	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3305	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3306	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3307	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3308	>	if (arg2 == NULL) {
3309	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3310	>	}
3311		{
3312	<	if (arg2) {
3313	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3314	<	strcpy((char *) arg1->key,arg2);
3315	<	}else {
3316	<	arg1->key = 0;
3312	>	try {
3313	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3314	>
3315	>	}catch (const BossSchedFailure & e) {
3316	>	PyErr_SetString ( SchedulerError, e.what() );
3317	>	return NULL;
3318	>	}catch (const std::exception& e) {
3319	>	PyErr_SetString ( BossError, e.what() );
3320	>	return NULL;
3321		}
3322		}
3323	<	Py_INCREF(Py_None); resultobj = Py_None;
3323	>	resultobj = result;
3324		return resultobj;
3325		fail:
3326		return NULL;
3327		}
3328
3329
3330	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3330	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3331		PyObject *resultobj;
3332	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3333	<	char *result;
3332	>	BossSession *arg1 = (BossSession *) 0 ;
3333	>	PyObject *result;
3334		PyObject * obj0 = 0 ;
3335
3336	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3337	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3338	<	result = (char *) ((arg1)->key);
3339	<
3340	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3336	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3337	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3338	>	{
3339	>	try {
3340	>	result = (PyObject *)BossSession_CHTools(arg1);
3341	>
3342	>	}catch (const BossSchedFailure & e) {
3343	>	PyErr_SetString ( SchedulerError, e.what() );
3344	>	return NULL;
3345	>	}catch (const std::exception& e) {
3346	>	PyErr_SetString ( BossError, e.what() );
3347	>	return NULL;
3348	>	}
3349	>	}
3350	>	resultobj = result;
3351		return resultobj;
3352		fail:
3353		return NULL;
3354		}
3355
3356
3357	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3357	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3358		PyObject *resultobj;
3359	<	char *arg1 ;
3360	<	BossTaskException *result;
3359	>	BossSession *arg1 = (BossSession *) 0 ;
3360	>	PyObject *result;
3361	>	PyObject * obj0 = 0 ;
3362
3363	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3363	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3364	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3365		{
3366		try {
3367	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3367	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3368
3369	+	}catch (const BossSchedFailure & e) {
3370	+	PyErr_SetString ( SchedulerError, e.what() );
3371	+	return NULL;
3372		}catch (const std::exception& e) {
3373	<	SWIG_exception(SWIG_RuntimeError, e.what());
3373	>	PyErr_SetString ( BossError, e.what() );
3374	>	return NULL;
3375		}
3376		}
3377	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3377	>	resultobj = result;
3378		return resultobj;
3379		fail:
3380		return NULL;
3381		}
3382
3383
3384	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3384	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3385		PyObject *resultobj;
3386	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3387	<	char *result;
3386	>	BossSession *arg1 = (BossSession *) 0 ;
3387	>	PyObject *result;
3388		PyObject * obj0 = 0 ;
3389
3390	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3391	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3390	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3391	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3392		{
3393		try {
3394	<	result = (char *)((BossTaskException const *)arg1)->what();
3394	>	result = (PyObject *)BossSession_RTMons(arg1);
3395
3396	+	}catch (const BossSchedFailure & e) {
3397	+	PyErr_SetString ( SchedulerError, e.what() );
3398	+	return NULL;
3399		}catch (const std::exception& e) {
3400	<	SWIG_exception(SWIG_RuntimeError, e.what());
3400	>	PyErr_SetString ( BossError, e.what() );
3401	>	return NULL;
3402		}
3403		}
3404	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3404	>	resultobj = result;
3405		return resultobj;
3406		fail:
3407		return NULL;
3408		}
3409
3410
3411	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3411	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3412		PyObject *resultobj;
3413	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3413	>	BossSession *arg1 = (BossSession *) 0 ;
3414	>	PyObject *result;
3415		PyObject * obj0 = 0 ;
3416
3417	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3418	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3417	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3418	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3419		{
3420		try {
3421	<	delete arg1;
3421	>	result = (PyObject *)BossSession_schedulers(arg1);
3422
3423	+	}catch (const BossSchedFailure & e) {
3424	+	PyErr_SetString ( SchedulerError, e.what() );
3425	+	return NULL;
3426		}catch (const std::exception& e) {
3427	<	SWIG_exception(SWIG_RuntimeError, e.what());
3427	>	PyErr_SetString ( BossError, e.what() );
3428	>	return NULL;
3429		}
3430		}
3431	<	Py_INCREF(Py_None); resultobj = Py_None;
3431	>	resultobj = result;
3432		return resultobj;
3433		fail:
3434		return NULL;
3435		}
3436
3437
3438	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
2875	<	PyObject *obj;
2876	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2877	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
2878	<	Py_INCREF(obj);
2879	<	return Py_BuildValue((char *)"");
2880	<	}
2881	<	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3438	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3439		PyObject *resultobj;
3440	<	BossTask *arg1 = (BossTask *) 0 ;
3441	<	PyObject *arg2 = (PyObject *) 0 ;
3442	<	BossAttributeContainer *arg3 = 0 ;
3440	>	BossSession *arg1 = (BossSession *) 0 ;
3441	>	std::string *arg2 = 0 ;
3442	>	std::string *arg3 = 0 ;
3443	>	std::string const &arg4_defvalue = "" ;
3444	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3445	>	std::string const &arg5_defvalue = "" ;
3446	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3447	>	bool arg6 = (bool) false ;
3448		PyObject *result;
3449	+	std::string temp2 ;
3450	+	std::string temp3 ;
3451	+	std::string temp4 ;
3452	+	std::string temp5 ;
3453		PyObject * obj0 = 0 ;
3454		PyObject * obj1 = 0 ;
3455		PyObject * obj2 = 0 ;
3456	+	PyObject * obj3 = 0 ;
3457	+	PyObject * obj4 = 0 ;
3458	+	PyObject * obj5 = 0 ;
3459
3460	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3461	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3462	<	arg2 = obj1;
3463	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3464	<	if (arg3 == NULL) {
3465	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3460	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3461	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3462	>	{
3463	>	if (PyString_Check(obj1)) {
3464	>	temp2 = std::string(PyString_AsString(obj1));
3465	>	arg2 = &temp2;
3466	>	}else {
3467	>	SWIG_exception(SWIG_TypeError, "string expected");
3468	>	}
3469	>	}
3470	>	{
3471	>	if (PyString_Check(obj2)) {
3472	>	temp3 = std::string(PyString_AsString(obj2));
3473	>	arg3 = &temp3;
3474	>	}else {
3475	>	SWIG_exception(SWIG_TypeError, "string expected");
3476	>	}
3477	>	}
3478	>	if (obj3) {
3479	>	{
3480	>	if (PyString_Check(obj3)) {
3481	>	temp4 = std::string(PyString_AsString(obj3));
3482	>	arg4 = &temp4;
3483	>	}else {
3484	>	SWIG_exception(SWIG_TypeError, "string expected");
3485	>	}
3486	>	}
3487	>	}
3488	>	if (obj4) {
3489	>	{
3490	>	if (PyString_Check(obj4)) {
3491	>	temp5 = std::string(PyString_AsString(obj4));
3492	>	arg5 = &temp5;
3493	>	}else {
3494	>	SWIG_exception(SWIG_TypeError, "string expected");
3495	>	}
3496	>	}
3497	>	}
3498	>	if (obj5) {
3499	>	arg6 = PyInt_AsLong(obj5) ? true : false;
3500	>	if (PyErr_Occurred()) SWIG_fail;
3501		}
3502		{
3503		try {
3504	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3504	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3505
3506	+	}catch (const BossSchedFailure & e) {
3507	+	PyErr_SetString ( SchedulerError, e.what() );
3508	+	return NULL;
3509		}catch (const std::exception& e) {
3510	<	SWIG_exception(SWIG_RuntimeError, e.what());
3510	>	PyErr_SetString ( BossError, e.what() );
3511	>	return NULL;
3512		}
3513		}
3514		resultobj = result;
#	Line 2910 | Line 3518 | static PyObject *_wrap_BossTask_appendTo
3518		}
3519
3520
3521	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3521	>	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3522		PyObject *resultobj;
3523	<	BossTask *arg1 = (BossTask *) 0 ;
3524	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3523	>	BossSession *arg1 = (BossSession *) 0 ;
3524	>	int arg2 = (int) SCHEDULED ;
3525	>	std::string const &arg3_defvalue = "all" ;
3526	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3527	>	std::string const &arg4_defvalue = "all" ;
3528	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3529	>	std::string const &arg5_defvalue = "" ;
3530	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3531	>	std::string arg6 = (std::string) "" ;
3532	>	std::string arg7 = (std::string) "" ;
3533	>	std::string arg8 = (std::string) "" ;
3534	>	std::string arg9 = (std::string) "" ;
3535	>	bool arg10 = (bool) false ;
3536		PyObject *result;
3537	+	std::string temp3 ;
3538	+	std::string temp4 ;
3539	+	std::string temp5 ;
3540		PyObject * obj0 = 0 ;
3541	<	PyObject * obj1 = 0 ;
3541	>	PyObject * obj2 = 0 ;
3542	>	PyObject * obj3 = 0 ;
3543	>	PyObject * obj4 = 0 ;
3544	>	PyObject * obj5 = 0 ;
3545	>	PyObject * obj6 = 0 ;
3546	>	PyObject * obj7 = 0 ;
3547	>	PyObject * obj8 = 0 ;
3548	>	PyObject * obj9 = 0 ;
3549
3550	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3551	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3552	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3553	<	if (arg2 == NULL) {
3554	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3550	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3551	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3552	>	if (obj2) {
3553	>	{
3554	>	if (PyString_Check(obj2)) {
3555	>	temp3 = std::string(PyString_AsString(obj2));
3556	>	arg3 = &temp3;
3557	>	}else {
3558	>	SWIG_exception(SWIG_TypeError, "string expected");
3559	>	}
3560	>	}
3561	>	}
3562	>	if (obj3) {
3563	>	{
3564	>	if (PyString_Check(obj3)) {
3565	>	temp4 = std::string(PyString_AsString(obj3));
3566	>	arg4 = &temp4;
3567	>	}else {
3568	>	SWIG_exception(SWIG_TypeError, "string expected");
3569	>	}
3570	>	}
3571	>	}
3572	>	if (obj4) {
3573	>	{
3574	>	if (PyString_Check(obj4)) {
3575	>	temp5 = std::string(PyString_AsString(obj4));
3576	>	arg5 = &temp5;
3577	>	}else {
3578	>	SWIG_exception(SWIG_TypeError, "string expected");
3579	>	}
3580	>	}
3581	>	}
3582	>	if (obj5) {
3583	>	{
3584	>	if (PyString_Check(obj5))
3585	>	arg6 = std::string(PyString_AsString(obj5));
3586	>	else
3587	>	SWIG_exception(SWIG_TypeError, "string expected");
3588	>	}
3589	>	}
3590	>	if (obj6) {
3591	>	{
3592	>	if (PyString_Check(obj6))
3593	>	arg7 = std::string(PyString_AsString(obj6));
3594	>	else
3595	>	SWIG_exception(SWIG_TypeError, "string expected");
3596	>	}
3597	>	}
3598	>	if (obj7) {
3599	>	{
3600	>	if (PyString_Check(obj7))
3601	>	arg8 = std::string(PyString_AsString(obj7));
3602	>	else
3603	>	SWIG_exception(SWIG_TypeError, "string expected");
3604	>	}
3605	>	}
3606	>	if (obj8) {
3607	>	{
3608	>	if (PyString_Check(obj8))
3609	>	arg9 = std::string(PyString_AsString(obj8));
3610	>	else
3611	>	SWIG_exception(SWIG_TypeError, "string expected");
3612	>	}
3613	>	}
3614	>	if (obj9) {
3615	>	arg10 = PyInt_AsLong(obj9) ? true : false;
3616	>	if (PyErr_Occurred()) SWIG_fail;
3617		}
3618		{
3619		try {
3620	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3620	>	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3621
3622	+	}catch (const BossSchedFailure & e) {
3623	+	PyErr_SetString ( SchedulerError, e.what() );
3624	+	return NULL;
3625		}catch (const std::exception& e) {
3626	<	SWIG_exception(SWIG_RuntimeError, e.what());
3626	>	PyErr_SetString ( BossError, e.what() );
3627	>	return NULL;
3628		}
3629		}
3630		resultobj = result;
#	Line 2939 | Line 3634 | static PyObject *_wrap_BossTask_jobDict(
3634		}
3635
3636
3637	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3637	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3638	>	PyObject *obj;
3639	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3640	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3641	>	Py_INCREF(obj);
3642	>	return Py_BuildValue((char *)"");
3643	>	}
3644	>	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3645		PyObject *resultobj;
3646	<	BossTask *arg1 = (BossTask *) 0 ;
3647	<	PyObject *result;
3646	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3647	>	char *arg2 ;
3648		PyObject * obj0 = 0 ;
3649
3650	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3651	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3650	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3651	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3652		{
3653	<	try {
3654	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3655	<
3656	<	}catch (const std::exception& e) {
3657	<	SWIG_exception(SWIG_RuntimeError, e.what());
3653	>	if (arg2) {
3654	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3655	>	strcpy((char *) arg1->key,arg2);
3656	>	}else {
3657	>	arg1->key = 0;
3658		}
3659		}
3660	<	resultobj = result;
3660	>	Py_INCREF(Py_None); resultobj = Py_None;
3661		return resultobj;
3662		fail:
3663		return NULL;
3664		}
3665
3666
3667	<	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3668	<	int argc;
3669	<	PyObject *argv[2];
3670	<	int ii;
3667	>	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3668	>	PyObject *resultobj;
3669	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3670	>	char *result;
3671	>	PyObject * obj0 = 0 ;
3672
3673	<	argc = PyObject_Length(args);
3674	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
3675	<	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	<	}
3673	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3674	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3675	>	result = (char *) ((arg1)->key);
3676
3677	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
3677	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3678	>	return resultobj;
3679	>	fail:
3680		return NULL;
3681		}
3682
3683
3684	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3684	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3685		PyObject *resultobj;
3686	<	BossTask *arg1 = (BossTask *) 0 ;
3687	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
2999	<	PyObject *result;
3000	<	PyObject * obj0 = 0 ;
3001	<	PyObject * obj1 = 0 ;
3686	>	char *arg1 ;
3687	>	BossTaskException *result;
3688
3689	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3004	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3005	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3006	<	if (arg2 == NULL) {
3007	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3008	<	}
3689	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3690		{
3691		try {
3692	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3692	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3693
3694	+	}catch (const BossSchedFailure & e) {
3695	+	PyErr_SetString ( SchedulerError, e.what() );
3696	+	return NULL;
3697		}catch (const std::exception& e) {
3698	<	SWIG_exception(SWIG_RuntimeError, e.what());
3698	>	PyErr_SetString ( BossError, e.what() );
3699	>	return NULL;
3700		}
3701		}
3702	<	resultobj = result;
3702	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3703		return resultobj;
3704		fail:
3705		return NULL;
3706		}
3707
3708
3709	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
3709	>	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3710		PyObject *resultobj;
3711	<	BossTask *arg1 = (BossTask *) 0 ;
3712	<	std::string *arg2 = 0 ;
3028	<	PyObject *result;
3029	<	std::string temp2 ;
3711	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3712	>	char *result;
3713		PyObject * obj0 = 0 ;
3031	–	PyObject * obj1 = 0 ;
3714
3715	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
3716	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3715	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3716	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3717		{
3718	<	if (PyString_Check(obj1)) {
3719	<	temp2 = std::string(PyString_AsString(obj1));
3720	<	arg2 = &temp2;
3721	<	}else {
3722	<	SWIG_exception(SWIG_TypeError, "string expected");
3718	>	try {
3719	>	result = (char *)((BossTaskException const *)arg1)->what();
3720	>
3721	>	}catch (const BossSchedFailure & e) {
3722	>	PyErr_SetString ( SchedulerError, e.what() );
3723	>	return NULL;
3724	>	}catch (const std::exception& e) {
3725	>	PyErr_SetString ( BossError, e.what() );
3726	>	return NULL;
3727		}
3728		}
3729	+	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3730	+	return resultobj;
3731	+	fail:
3732	+	return NULL;
3733	+	}
3734	+
3735	+
3736	+	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3737	+	PyObject *resultobj;
3738	+	BossTaskException *arg1 = (BossTaskException *) 0 ;
3739	+	PyObject * obj0 = 0 ;
3740	+
3741	+	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3742	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3743		{
3744		try {
3745	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
3745	>	delete arg1;
3746
3747	+	}catch (const BossSchedFailure & e) {
3748	+	PyErr_SetString ( SchedulerError, e.what() );
3749	+	return NULL;
3750		}catch (const std::exception& e) {
3751	<	SWIG_exception(SWIG_RuntimeError, e.what());
3751	>	PyErr_SetString ( BossError, e.what() );
3752	>	return NULL;
3753		}
3754		}
3755	<	resultobj = result;
3755	>	Py_INCREF(Py_None); resultobj = Py_None;
3756		return resultobj;
3757		fail:
3758		return NULL;
3759		}
3760
3761
3762	+	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3763	+	PyObject *obj;
3764	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3765	+	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3766	+	Py_INCREF(obj);
3767	+	return Py_BuildValue((char *)"");
3768	+	}
3769		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
3770		PyObject *resultobj;
3771		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 3067 | Line 3778 | static PyObject *_wrap_new_BossTask__SWI
3778		try {
3779		result = (BossTask *)new BossTask(arg1);
3780
3781	+	}catch (const BossSchedFailure & e) {
3782	+	PyErr_SetString ( SchedulerError, e.what() );
3783	+	return NULL;
3784		}catch (const std::exception& e) {
3785	<	SWIG_exception(SWIG_RuntimeError, e.what());
3785	>	PyErr_SetString ( BossError, e.what() );
3786	>	return NULL;
3787		}
3788		}
3789		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3101 | Line 3816 | static PyObject *_wrap_new_BossTask__SWI
3816		try {
3817		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3818
3819	+	}catch (const BossSchedFailure & e) {
3820	+	PyErr_SetString ( SchedulerError, e.what() );
3821	+	return NULL;
3822		}catch (const std::exception& e) {
3823	<	SWIG_exception(SWIG_RuntimeError, e.what());
3823	>	PyErr_SetString ( BossError, e.what() );
3824	>	return NULL;
3825		}
3826		}
3827		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3123 | Line 3842 | static PyObject *_wrap_delete_BossTask(P
3842		try {
3843		delete arg1;
3844
3845	+	}catch (const BossSchedFailure & e) {
3846	+	PyErr_SetString ( SchedulerError, e.what() );
3847	+	return NULL;
3848		}catch (const std::exception& e) {
3849	<	SWIG_exception(SWIG_RuntimeError, e.what());
3849	>	PyErr_SetString ( BossError, e.what() );
3850	>	return NULL;
3851		}
3852		}
3853		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3149 | Line 3872 | static PyObject *_wrap_new_BossTask__SWI
3872		try {
3873		result = (BossTask *)new BossTask((BossTask const &)*arg1);
3874
3875	+	}catch (const BossSchedFailure & e) {
3876	+	PyErr_SetString ( SchedulerError, e.what() );
3877	+	return NULL;
3878		}catch (const std::exception& e) {
3879	<	SWIG_exception(SWIG_RuntimeError, e.what());
3879	>	PyErr_SetString ( BossError, e.what() );
3880	>	return NULL;
3881		}
3882		}
3883		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3240 | Line 3967 | static PyObject *_wrap_BossTask_id(PyObj
3967		result = (std::string *) &_result_ref;
3968		}
3969
3970	+	}catch (const BossSchedFailure & e) {
3971	+	PyErr_SetString ( SchedulerError, e.what() );
3972	+	return NULL;
3973		}catch (const std::exception& e) {
3974	<	SWIG_exception(SWIG_RuntimeError, e.what());
3974	>	PyErr_SetString ( BossError, e.what() );
3975	>	return NULL;
3976		}
3977		}
3978		{
#	Line 3268 | Line 3999 | static PyObject *_wrap_BossTask_name(PyO
3999		result = (std::string *) &_result_ref;
4000		}
4001
4002	+	}catch (const BossSchedFailure & e) {
4003	+	PyErr_SetString ( SchedulerError, e.what() );
4004	+	return NULL;
4005		}catch (const std::exception& e) {
4006	<	SWIG_exception(SWIG_RuntimeError, e.what());
4006	>	PyErr_SetString ( BossError, e.what() );
4007	>	return NULL;
4008		}
4009		}
4010		{
#	Line 3281 | Line 4016 | static PyObject *_wrap_BossTask_name(PyO
4016		}
4017
4018
4019	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
4019	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4020		PyObject *resultobj;
4021		BossTask *arg1 = (BossTask *) 0 ;
4022	<	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4022	>	std::map<std::string,std::string > result;
4023		PyObject * obj0 = 0 ;
4024
4025	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4025	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4026		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4027		{
4028		try {
4029	<	result = ((BossTask const *)arg1)->jobsMap();
4029	>	result = ((BossTask const *)arg1)->taskMap();
4030
4031	+	}catch (const BossSchedFailure & e) {
4032	+	PyErr_SetString ( SchedulerError, e.what() );
4033	+	return NULL;
4034		}catch (const std::exception& e) {
4035	<	SWIG_exception(SWIG_RuntimeError, e.what());
4035	>	PyErr_SetString ( BossError, e.what() );
4036	>	return NULL;
4037		}
4038		}
4039		{
4040	<	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4041	<	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4042	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4040	>	resultobj = PyDict_New();
4041	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4042	>	PyDict_SetItem(resultobj,
4043	>	SwigString_FromString(i->first),
4044	>	SwigString_FromString(i->second));
4045	>	}
4046		}
4047		return resultobj;
4048		fail:
#	Line 3308 | Line 4050 | static PyObject *_wrap_BossTask_jobsMap_
4050		}
4051
4052
4053	<	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4053	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
4054		PyObject *resultobj;
4055		BossTask *arg1 = (BossTask *) 0 ;
4056	<	unsigned int arg2 ;
3315	<	std::map<std::string,std::string > result;
4056	>	BossTask::job_iterator result;
4057		PyObject * obj0 = 0 ;
3317	–	PyObject * obj1 = 0 ;
4058
4059	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4059	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
4060		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;
4061		{
4062		try {
4063	<	result = ((BossTask const *)arg1)->jobMap(arg2);
4063	>	result = ((BossTask const *)arg1)->job_begin();
4064
4065	+	}catch (const BossSchedFailure & e) {
4066	+	PyErr_SetString ( SchedulerError, e.what() );
4067	+	return NULL;
4068		}catch (const std::exception& e) {
4069	<	SWIG_exception(SWIG_RuntimeError, e.what());
4069	>	PyErr_SetString ( BossError, e.what() );
4070	>	return NULL;
4071		}
4072		}
4073		{
4074	<	resultobj = PyDict_New();
4075	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4076	<	PyDict_SetItem(resultobj,
4077	<	SwigString_FromString(i->first),
4078	<	SwigString_FromString(i->second));
4074	>	BossTask::job_iterator * resultptr;
4075	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4076	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4077	>	}
4078	>	return resultobj;
4079	>	fail:
4080	>	return NULL;
4081	>	}
4082	>
4083	>
4084	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4085	>	PyObject *resultobj;
4086	>	BossTask *arg1 = (BossTask *) 0 ;
4087	>	BossTask::job_iterator result;
4088	>	PyObject * obj0 = 0 ;
4089	>
4090	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4091	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4092	>	{
4093	>	try {
4094	>	result = ((BossTask const *)arg1)->job_end();
4095	>
4096	>	}catch (const BossSchedFailure & e) {
4097	>	PyErr_SetString ( SchedulerError, e.what() );
4098	>	return NULL;
4099	>	}catch (const std::exception& e) {
4100	>	PyErr_SetString ( BossError, e.what() );
4101	>	return NULL;
4102		}
4103		}
4104	+	{
4105	+	BossTask::job_iterator * resultptr;
4106	+	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4107	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4108	+	}
4109		return resultobj;
4110		fail:
4111		return NULL;
4112		}
4113
4114
4115	<	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4115	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4116	>	PyObject *resultobj;
4117	>	BossTask *arg1 = (BossTask *) 0 ;
4118	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4119	>	PyObject * obj0 = 0 ;
4120	>
4121	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4122	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4123	>	{
4124	>	try {
4125	>	result = ((BossTask const *)arg1)->jobsMap();
4126	>
4127	>	}catch (const BossSchedFailure & e) {
4128	>	PyErr_SetString ( SchedulerError, e.what() );
4129	>	return NULL;
4130	>	}catch (const std::exception& e) {
4131	>	PyErr_SetString ( BossError, e.what() );
4132	>	return NULL;
4133	>	}
4134	>	}
4135	>	{
4136	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4137	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4138	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4139	>	}
4140	>	return resultobj;
4141	>	fail:
4142	>	return NULL;
4143	>	}
4144	>
4145	>
4146	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4147		PyObject *resultobj;
4148		BossTask *arg1 = (BossTask *) 0 ;
4149		SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
#	Line 3365 | Line 4166 | static PyObject *_wrap_BossTask_jobMap__
4166		try {
4167		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4168
4169	+	}catch (const BossSchedFailure & e) {
4170	+	PyErr_SetString ( SchedulerError, e.what() );
4171	+	return NULL;
4172		}catch (const std::exception& e) {
4173	<	SWIG_exception(SWIG_RuntimeError, e.what());
4173	>	PyErr_SetString ( BossError, e.what() );
4174	>	return NULL;
4175		}
4176		}
4177		{
#	Line 3378 | Line 4183 | static PyObject *_wrap_BossTask_jobMap__
4183		}
4184
4185
4186	+	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4187	+	PyObject *resultobj;
4188	+	BossTask *arg1 = (BossTask *) 0 ;
4189	+	unsigned int arg2 ;
4190	+	std::map<std::string,std::string > result;
4191	+	PyObject * obj0 = 0 ;
4192	+	PyObject * obj1 = 0 ;
4193	+
4194	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4195	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4196	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
4197	+	if (PyErr_Occurred()) SWIG_fail;
4198	+	{
4199	+	try {
4200	+	result = ((BossTask const *)arg1)->jobMap(arg2);
4201	+
4202	+	}catch (const BossSchedFailure & e) {
4203	+	PyErr_SetString ( SchedulerError, e.what() );
4204	+	return NULL;
4205	+	}catch (const std::exception& e) {
4206	+	PyErr_SetString ( BossError, e.what() );
4207	+	return NULL;
4208	+	}
4209	+	}
4210	+	{
4211	+	resultobj = PyDict_New();
4212	+	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4213	+	PyDict_SetItem(resultobj,
4214	+	SwigString_FromString(i->first),
4215	+	SwigString_FromString(i->second));
4216	+	}
4217	+	}
4218	+	return resultobj;
4219	+	fail:
4220	+	return NULL;
4221	+	}
4222	+
4223	+
4224		static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
4225		int argc;
4226		PyObject *argv[4];
#	Line 3403 | Line 4246 | static PyObject *_wrap_BossTask_jobMap(P
4246		_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
4247		}
4248		if (_v) {
4249	<	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4249	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4250		}
4251		}
4252		}
#	Line 3439 | Line 4282 | static PyObject *_wrap_BossTask_jobMap(P
4282		}
4283		}
4284		if (_v) {
4285	<	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4285	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4286		}
4287		}
4288		}
#	Line 3450 | Line 4293 | static PyObject *_wrap_BossTask_jobMap(P
4293		}
4294
4295
4296	<	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) {
4296	>	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4297		PyObject *resultobj;
4298		BossTask *arg1 = (BossTask *) 0 ;
4299	<	BossTask::job_iterator result;
4299	>	BossJob *arg2 = (BossJob *) 0 ;
4300	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4301		PyObject * obj0 = 0 ;
4302	+	PyObject * obj1 = 0 ;
4303
4304	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4304	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
4305		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4306	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4307		{
4308		try {
4309	<	result = ((BossTask const *)arg1)->job_end();
4309	>	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4310
4311	+	}catch (const BossSchedFailure & e) {
4312	+	PyErr_SetString ( SchedulerError, e.what() );
4313	+	return NULL;
4314		}catch (const std::exception& e) {
4315	<	SWIG_exception(SWIG_RuntimeError, e.what());
4315	>	PyErr_SetString ( BossError, e.what() );
4316	>	return NULL;
4317		}
4318		}
4319		{
4320	<	BossTask::job_iterator * resultptr;
4321	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4322	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4320	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4321	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4322	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4323		}
4324		return resultobj;
4325		fail:
#	Line 3519 | Line 4342 | static PyObject *_wrap_BossTask_queryJob
4342		try {
4343		result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4344
4345	+	}catch (const BossSchedFailure & e) {
4346	+	PyErr_SetString ( SchedulerError, e.what() );
4347	+	return NULL;
4348		}catch (const std::exception& e) {
4349	<	SWIG_exception(SWIG_RuntimeError, e.what());
4349	>	PyErr_SetString ( BossError, e.what() );
4350	>	return NULL;
4351		}
4352		}
4353		{
#	Line 3534 | Line 4361 | static PyObject *_wrap_BossTask_queryJob
4361		}
4362
4363
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	–
4364		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4365		PyObject *resultobj;
4366		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3600 | Line 4397 | static PyObject *_wrap_BossTask_declare_
4397		try {
4398		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4399
4400	+	}catch (const BossSchedFailure & e) {
4401	+	PyErr_SetString ( SchedulerError, e.what() );
4402	+	return NULL;
4403		}catch (const std::exception& e) {
4404	<	SWIG_exception(SWIG_RuntimeError, e.what());
4404	>	PyErr_SetString ( BossError, e.what() );
4405	>	return NULL;
4406		}
4407		}
4408		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3639 | Line 4440 | static PyObject *_wrap_BossTask_declare_
4440		try {
4441		(arg1)->declare(arg2,(std::string const &)*arg3);
4442
4443	+	}catch (const BossSchedFailure & e) {
4444	+	PyErr_SetString ( SchedulerError, e.what() );
4445	+	return NULL;
4446		}catch (const std::exception& e) {
4447	<	SWIG_exception(SWIG_RuntimeError, e.what());
4447	>	PyErr_SetString ( BossError, e.what() );
4448	>	return NULL;
4449		}
4450		}
4451		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3738 | Line 4543 | static PyObject *_wrap_BossTask_remove(P
4543		try {
4544		(arg1)->remove();
4545
4546	+	}catch (const BossSchedFailure & e) {
4547	+	PyErr_SetString ( SchedulerError, e.what() );
4548	+	return NULL;
4549		}catch (const std::exception& e) {
4550	<	SWIG_exception(SWIG_RuntimeError, e.what());
4550	>	PyErr_SetString ( BossError, e.what() );
4551	>	return NULL;
4552		}
4553		}
4554		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3774 | Line 4583 | static PyObject *_wrap_BossTask_archive(
4583		try {
4584		(arg1)->archive((std::string const &)*arg2);
4585
4586	+	}catch (const BossSchedFailure & e) {
4587	+	PyErr_SetString ( SchedulerError, e.what() );
4588	+	return NULL;
4589		}catch (const std::exception& e) {
4590	<	SWIG_exception(SWIG_RuntimeError, e.what());
4590	>	PyErr_SetString ( BossError, e.what() );
4591	>	return NULL;
4592		}
4593		}
4594		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3785 | Line 4598 | static PyObject *_wrap_BossTask_archive(
4598		}
4599
4600
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	–
4601		static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4602		PyObject *resultobj;
4603		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3903 | Line 4686 | static PyObject *_wrap_BossTask_submit(P
4686		try {
4687		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);
4688
4689	+	}catch (const BossSchedFailure & e) {
4690	+	PyErr_SetString ( SchedulerError, e.what() );
4691	+	return NULL;
4692		}catch (const std::exception& e) {
4693	<	SWIG_exception(SWIG_RuntimeError, e.what());
4693	>	PyErr_SetString ( BossError, e.what() );
4694	>	return NULL;
4695		}
4696		}
4697		resultobj = PyInt_FromLong((long)result);
#	Line 3943 | Line 4730 | static PyObject *_wrap_BossTask_reSubmit
4730		try {
4731		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4732
4733	+	}catch (const BossSchedFailure & e) {
4734	+	PyErr_SetString ( SchedulerError, e.what() );
4735	+	return NULL;
4736		}catch (const std::exception& e) {
4737	<	SWIG_exception(SWIG_RuntimeError, e.what());
4737	>	PyErr_SetString ( BossError, e.what() );
4738	>	return NULL;
4739		}
4740		}
4741		resultobj = PyInt_FromLong((long)result);
#	Line 3983 | Line 4774 | static PyObject *_wrap_BossTask_kill(PyO
4774		try {
4775		result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4776
4777	+	}catch (const BossSchedFailure & e) {
4778	+	PyErr_SetString ( SchedulerError, e.what() );
4779	+	return NULL;
4780		}catch (const std::exception& e) {
4781	<	SWIG_exception(SWIG_RuntimeError, e.what());
4781	>	PyErr_SetString ( BossError, e.what() );
4782	>	return NULL;
4783		}
4784		}
4785		resultobj = PyInt_FromLong((long)result);
#	Line 3994 | Line 4789 | static PyObject *_wrap_BossTask_kill(PyO
4789		}
4790
4791
4792	<	static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
4792	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4793		PyObject *resultobj;
4794		BossTask *arg1 = (BossTask *) 0 ;
4795		std::string const &arg2_defvalue = "all" ;
#	Line 4046 | Line 4841 | static PyObject *_wrap_BossTask_getOutpu
4841		try {
4842		result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4843
4844	+	}catch (const BossSchedFailure & e) {
4845	+	PyErr_SetString ( SchedulerError, e.what() );
4846	+	return NULL;
4847		}catch (const std::exception& e) {
4848	<	SWIG_exception(SWIG_RuntimeError, e.what());
4848	>	PyErr_SetString ( BossError, e.what() );
4849	>	return NULL;
4850		}
4851		}
4852		resultobj = PyInt_FromLong((long)result);
#	Line 4057 | Line 4856 | static PyObject *_wrap_BossTask_getOutpu
4856		}
4857
4858
4859	<	static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
4859	>	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
4860		PyObject *resultobj;
4861		BossTask *arg1 = (BossTask *) 0 ;
4862	<	std::string const &arg2_defvalue = "" ;
4863	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
4864	<	bool arg3 = (bool) false ;
4865	<	bool arg4 = (bool) false ;
4862	>	int arg2 = (int) SCHEDULED ;
4863	>	std::string const &arg3_defvalue = "all" ;
4864	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4865	>	std::string const &arg4_defvalue = "" ;
4866	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4867	>	std::string arg5 = (std::string) "" ;
4868	>	std::string arg6 = (std::string) "" ;
4869	>	std::string arg7 = (std::string) "" ;
4870	>	std::string arg8 = (std::string) "" ;
4871		int result;
4872	<	std::string temp2 ;
4872	>	std::string temp3 ;
4873	>	std::string temp4 ;
4874		PyObject * obj0 = 0 ;
4070	–	PyObject * obj1 = 0 ;
4875		PyObject * obj2 = 0 ;
4876		PyObject * obj3 = 0 ;
4877	+	PyObject * obj4 = 0 ;
4878	+	PyObject * obj5 = 0 ;
4879	+	PyObject * obj6 = 0 ;
4880	+	PyObject * obj7 = 0 ;
4881
4882	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4882	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4883		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4884	<	if (obj1) {
4884	>	if (obj2) {
4885		{
4886	<	if (PyString_Check(obj1)) {
4887	<	temp2 = std::string(PyString_AsString(obj1));
4888	<	arg2 = &temp2;
4886	>	if (PyString_Check(obj2)) {
4887	>	temp3 = std::string(PyString_AsString(obj2));
4888	>	arg3 = &temp3;
4889		}else {
4890		SWIG_exception(SWIG_TypeError, "string expected");
4891		}
4892		}
4893		}
4086	–	if (obj2) {
4087	–	arg3 = PyInt_AsLong(obj2) ? true : false;
4088	–	if (PyErr_Occurred()) SWIG_fail;
4089	–	}
4894		if (obj3) {
4895	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4896	<	if (PyErr_Occurred()) SWIG_fail;
4897	<	}
4898	<	{
4899	<	try {
4900	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
4901	<
4098	<	}catch (const std::exception& e) {
4099	<	SWIG_exception(SWIG_RuntimeError, e.what());
4895	>	{
4896	>	if (PyString_Check(obj3)) {
4897	>	temp4 = std::string(PyString_AsString(obj3));
4898	>	arg4 = &temp4;
4899	>	}else {
4900	>	SWIG_exception(SWIG_TypeError, "string expected");
4901	>	}
4902		}
4903		}
4904	<	resultobj = PyInt_FromLong((long)result);
4905	<	return resultobj;
4906	<	fail:
4907	<	return NULL;
4908	<	}
4909	<
4910	<
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);
4904	>	if (obj4) {
4905	>	{
4906	>	if (PyString_Check(obj4))
4907	>	arg5 = std::string(PyString_AsString(obj4));
4908	>	else
4909	>	SWIG_exception(SWIG_TypeError, "string expected");
4910	>	}
4911		}
4912	<	if ((argc >= 1) && (argc <= 5)) {
4119	<	int _v;
4912	>	if (obj5) {
4913		{
4914	<	void *ptr;
4915	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4916	<	_v = 0;
4917	<	PyErr_Clear();
4125	<	}else {
4126	<	_v = 1;
4127	<	}
4914	>	if (PyString_Check(obj5))
4915	>	arg6 = std::string(PyString_AsString(obj5));
4916	>	else
4917	>	SWIG_exception(SWIG_TypeError, "string expected");
4918		}
4919	<	if (_v) {
4920	<	if (argc <= 1) {
4921	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4922	<	}
4923	<	{
4924	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4925	<	}
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	<	}
4919	>	}
4920	>	if (obj6) {
4921	>	{
4922	>	if (PyString_Check(obj6))
4923	>	arg7 = std::string(PyString_AsString(obj6));
4924	>	else
4925	>	SWIG_exception(SWIG_TypeError, "string expected");
4926		}
4927		}
4928	<	if ((argc >= 1) && (argc <= 4)) {
4166	<	int _v;
4928	>	if (obj7) {
4929		{
4930	<	void *ptr;
4931	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4932	<	_v = 0;
4933	<	PyErr_Clear();
4172	<	}else {
4173	<	_v = 1;
4174	<	}
4930	>	if (PyString_Check(obj7))
4931	>	arg8 = std::string(PyString_AsString(obj7));
4932	>	else
4933	>	SWIG_exception(SWIG_TypeError, "string expected");
4934		}
4935	<	if (_v) {
4936	<	if (argc <= 1) {
4937	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4938	<	}
4939	<	{
4940	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4941	<	}
4942	<	if (_v) {
4943	<	if (argc <= 2) {
4944	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4945	<	}
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	<	}
4935	>	}
4936	>	{
4937	>	try {
4938	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4939	>
4940	>	}catch (const BossSchedFailure & e) {
4941	>	PyErr_SetString ( SchedulerError, e.what() );
4942	>	return NULL;
4943	>	}catch (const std::exception& e) {
4944	>	PyErr_SetString ( BossError, e.what() );
4945	>	return NULL;
4946		}
4947		}
4948	<
4949	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
4948	>	resultobj = PyInt_FromLong((long)result);
4949	>	return resultobj;
4950	>	fail:
4951		return NULL;
4952		}
4953
#	Line 4294 | Line 5039 | static PyObject *_wrap_BossTask_query(Py
5039		try {
5040		result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5041
5042	+	}catch (const BossSchedFailure & e) {
5043	+	PyErr_SetString ( SchedulerError, e.what() );
5044	+	return NULL;
5045		}catch (const std::exception& e) {
5046	<	SWIG_exception(SWIG_RuntimeError, e.what());
5046	>	PyErr_SetString ( BossError, e.what() );
5047	>	return NULL;
5048		}
5049		}
5050		resultobj = PyInt_FromLong((long)result);
#	Line 4353 | Line 5102 | static PyObject *_wrap_BossTask_query_ou
5102		try {
5103		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5104
5105	+	}catch (const BossSchedFailure & e) {
5106	+	PyErr_SetString ( SchedulerError, e.what() );
5107	+	return NULL;
5108		}catch (const std::exception& e) {
5109	<	SWIG_exception(SWIG_RuntimeError, e.what());
5109	>	PyErr_SetString ( BossError, e.what() );
5110	>	return NULL;
5111		}
5112		}
5113		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4375 | Line 5128 | static PyObject *_wrap_BossTask_clear(Py
5128		try {
5129		(arg1)->clear();
5130
5131	+	}catch (const BossSchedFailure & e) {
5132	+	PyErr_SetString ( SchedulerError, e.what() );
5133	+	return NULL;
5134		}catch (const std::exception& e) {
5135	<	SWIG_exception(SWIG_RuntimeError, e.what());
5135	>	PyErr_SetString ( BossError, e.what() );
5136	>	return NULL;
5137		}
5138		}
5139		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4386 | Line 5143 | static PyObject *_wrap_BossTask_clear(Py
5143		}
5144
5145
5146	<	static PyObject *_wrap_BossTask_prompt(PyObject *self, PyObject *args) {
5146	>	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5147	>	PyObject *resultobj;
5148	>	BossTask *arg1 = (BossTask *) 0 ;
5149	>	PyObject *arg2 = (PyObject *) 0 ;
5150	>	BossAttributeContainer *arg3 = 0 ;
5151	>	PyObject *result;
5152	>	PyObject * obj0 = 0 ;
5153	>	PyObject * obj1 = 0 ;
5154	>	PyObject * obj2 = 0 ;
5155	>
5156	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5157	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5158	>	arg2 = obj1;
5159	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5160	>	if (arg3 == NULL) {
5161	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5162	>	}
5163	>	{
5164	>	try {
5165	>	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5166	>
5167	>	}catch (const BossSchedFailure & e) {
5168	>	PyErr_SetString ( SchedulerError, e.what() );
5169	>	return NULL;
5170	>	}catch (const std::exception& e) {
5171	>	PyErr_SetString ( BossError, e.what() );
5172	>	return NULL;
5173	>	}
5174	>	}
5175	>	resultobj = result;
5176	>	return resultobj;
5177	>	fail:
5178	>	return NULL;
5179	>	}
5180	>
5181	>
5182	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5183	>	PyObject *resultobj;
5184	>	BossTask *arg1 = (BossTask *) 0 ;
5185	>	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5186	>	PyObject *result;
5187	>	PyObject * obj0 = 0 ;
5188	>	PyObject * obj1 = 0 ;
5189	>
5190	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
5191	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5192	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5193	>	if (arg2 == NULL) {
5194	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5195	>	}
5196	>	{
5197	>	try {
5198	>	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
5199	>
5200	>	}catch (const BossSchedFailure & e) {
5201	>	PyErr_SetString ( SchedulerError, e.what() );
5202	>	return NULL;
5203	>	}catch (const std::exception& e) {
5204	>	PyErr_SetString ( BossError, e.what() );
5205	>	return NULL;
5206	>	}
5207	>	}
5208	>	resultobj = result;
5209	>	return resultobj;
5210	>	fail:
5211	>	return NULL;
5212	>	}
5213	>
5214	>
5215	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5216	>	PyObject *resultobj;
5217	>	BossTask *arg1 = (BossTask *) 0 ;
5218	>	PyObject *result;
5219	>	PyObject * obj0 = 0 ;
5220	>
5221	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5222	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5223	>	{
5224	>	try {
5225	>	result = (PyObject *)BossTask_jobsDict(arg1);
5226	>
5227	>	}catch (const BossSchedFailure & e) {
5228	>	PyErr_SetString ( SchedulerError, e.what() );
5229	>	return NULL;
5230	>	}catch (const std::exception& e) {
5231	>	PyErr_SetString ( BossError, e.what() );
5232	>	return NULL;
5233	>	}
5234	>	}
5235	>	resultobj = result;
5236	>	return resultobj;
5237	>	fail:
5238	>	return NULL;
5239	>	}
5240	>
5241	>
5242	>	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5243	>	PyObject *resultobj;
5244	>	BossTask *arg1 = (BossTask *) 0 ;
5245	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5246	>	PyObject *result;
5247	>	PyObject * obj0 = 0 ;
5248	>	PyObject * obj1 = 0 ;
5249	>
5250	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5251	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5252	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5253	>	if (arg2 == NULL) {
5254	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5255	>	}
5256	>	{
5257	>	try {
5258	>	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5259	>
5260	>	}catch (const BossSchedFailure & e) {
5261	>	PyErr_SetString ( SchedulerError, e.what() );
5262	>	return NULL;
5263	>	}catch (const std::exception& e) {
5264	>	PyErr_SetString ( BossError, e.what() );
5265	>	return NULL;
5266	>	}
5267	>	}
5268	>	resultobj = result;
5269	>	return resultobj;
5270	>	fail:
5271	>	return NULL;
5272	>	}
5273	>
5274	>
5275	>	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5276		PyObject *resultobj;
5277		BossTask *arg1 = (BossTask *) 0 ;
5278		std::string *arg2 = 0 ;
5279	<	bool result;
5279	>	PyObject *result;
5280		std::string temp2 ;
5281		PyObject * obj0 = 0 ;
5282		PyObject * obj1 = 0 ;
5283
5284	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_prompt",&obj0,&obj1)) goto fail;
5284	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5285		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5286		{
5287		if (PyString_Check(obj1)) {
#	Line 4407 | Line 5293 | static PyObject *_wrap_BossTask_prompt(P
5293		}
5294		{
5295		try {
5296	<	result = (bool)(arg1)->prompt((std::string const &)*arg2);
5296	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5297
5298	+	}catch (const BossSchedFailure & e) {
5299	+	PyErr_SetString ( SchedulerError, e.what() );
5300	+	return NULL;
5301		}catch (const std::exception& e) {
5302	<	SWIG_exception(SWIG_RuntimeError, e.what());
5302	>	PyErr_SetString ( BossError, e.what() );
5303	>	return NULL;
5304		}
5305		}
5306	<	resultobj = PyInt_FromLong((long)result);
5306	>	resultobj = result;
5307		return resultobj;
5308		fail:
5309		return NULL;
#	Line 4430 | Line 5320 | static PyObject * BossTask_swigregister(
5320		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
5321		PyObject *resultobj;
5322		std::string arg1 = (std::string) "" ;
5323	<	bool arg2 = (bool) false ;
5323	>	std::string arg2 = (std::string) "2" ;
5324	>	std::string arg3 = (std::string) "" ;
5325	>	std::string arg4 = (std::string) "" ;
5326	>	bool arg5 = (bool) false ;
5327		BossAdministratorSession *result;
5328		PyObject * obj0 = 0 ;
5329		PyObject * obj1 = 0 ;
5330	+	PyObject * obj2 = 0 ;
5331	+	PyObject * obj3 = 0 ;
5332	+	PyObject * obj4 = 0 ;
5333
5334	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
5334	>	if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5335		if (obj0) {
5336		{
5337		if (PyString_Check(obj0))
#	Line 4445 | Line 5341 | static PyObject *_wrap_new_BossAdministr
5341		}
5342		}
5343		if (obj1) {
5344	<	arg2 = PyInt_AsLong(obj1) ? true : false;
5344	>	{
5345	>	if (PyString_Check(obj1))
5346	>	arg2 = std::string(PyString_AsString(obj1));
5347	>	else
5348	>	SWIG_exception(SWIG_TypeError, "string expected");
5349	>	}
5350	>	}
5351	>	if (obj2) {
5352	>	{
5353	>	if (PyString_Check(obj2))
5354	>	arg3 = std::string(PyString_AsString(obj2));
5355	>	else
5356	>	SWIG_exception(SWIG_TypeError, "string expected");
5357	>	}
5358	>	}
5359	>	if (obj3) {
5360	>	{
5361	>	if (PyString_Check(obj3))
5362	>	arg4 = std::string(PyString_AsString(obj3));
5363	>	else
5364	>	SWIG_exception(SWIG_TypeError, "string expected");
5365	>	}
5366	>	}
5367	>	if (obj4) {
5368	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5369		if (PyErr_Occurred()) SWIG_fail;
5370		}
5371		{
5372		try {
5373	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
5373	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5374
5375	+	}catch (const BossSchedFailure & e) {
5376	+	PyErr_SetString ( SchedulerError, e.what() );
5377	+	return NULL;
5378		}catch (const std::exception& e) {
5379	<	SWIG_exception(SWIG_RuntimeError, e.what());
5379	>	PyErr_SetString ( BossError, e.what() );
5380	>	return NULL;
5381		}
5382		}
5383		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 4474 | Line 5398 | static PyObject *_wrap_delete_BossAdmini
5398		try {
5399		delete arg1;
5400
5401	+	}catch (const BossSchedFailure & e) {
5402	+	PyErr_SetString ( SchedulerError, e.what() );
5403	+	return NULL;
5404		}catch (const std::exception& e) {
5405	<	SWIG_exception(SWIG_RuntimeError, e.what());
5405	>	PyErr_SetString ( BossError, e.what() );
5406	>	return NULL;
5407		}
5408		}
5409		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4485 | Line 5413 | static PyObject *_wrap_delete_BossAdmini
5413		}
5414
5415
5416	+	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
5417	+	PyObject *resultobj;
5418	+	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5419	+	int result;
5420	+	PyObject * obj0 = 0 ;
5421	+
5422	+	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
5423	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5424	+	{
5425	+	try {
5426	+	result = (int)(arg1)->configureDB();
5427	+
5428	+	}catch (const BossSchedFailure & e) {
5429	+	PyErr_SetString ( SchedulerError, e.what() );
5430	+	return NULL;
5431	+	}catch (const std::exception& e) {
5432	+	PyErr_SetString ( BossError, e.what() );
5433	+	return NULL;
5434	+	}
5435	+	}
5436	+	resultobj = PyInt_FromLong((long)result);
5437	+	return resultobj;
5438	+	fail:
5439	+	return NULL;
5440	+	}
5441	+
5442	+
5443		static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
5444		PyObject *resultobj;
5445		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
#	Line 4508 | Line 5463 | static PyObject *_wrap_BossAdministrator
5463		try {
5464		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5465
5466	+	}catch (const BossSchedFailure & e) {
5467	+	PyErr_SetString ( SchedulerError, e.what() );
5468	+	return NULL;
5469		}catch (const std::exception& e) {
5470	<	SWIG_exception(SWIG_RuntimeError, e.what());
5470	>	PyErr_SetString ( BossError, e.what() );
5471	>	return NULL;
5472		}
5473		}
5474		resultobj = PyInt_FromLong((long)result);
#	Line 4542 | Line 5501 | static PyObject *_wrap_BossAdministrator
5501		try {
5502		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5503
5504	+	}catch (const BossSchedFailure & e) {
5505	+	PyErr_SetString ( SchedulerError, e.what() );
5506	+	return NULL;
5507		}catch (const std::exception& e) {
5508	<	SWIG_exception(SWIG_RuntimeError, e.what());
5508	>	PyErr_SetString ( BossError, e.what() );
5509	>	return NULL;
5510		}
5511		}
5512		resultobj = PyInt_FromLong((long)result);
#	Line 4576 | Line 5539 | static PyObject *_wrap_BossAdministrator
5539		try {
5540		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5541
5542	+	}catch (const BossSchedFailure & e) {
5543	+	PyErr_SetString ( SchedulerError, e.what() );
5544	+	return NULL;
5545		}catch (const std::exception& e) {
5546	<	SWIG_exception(SWIG_RuntimeError, e.what());
5546	>	PyErr_SetString ( BossError, e.what() );
5547	>	return NULL;
5548		}
5549		}
5550		resultobj = PyInt_FromLong((long)result);
#	Line 4610 | Line 5577 | static PyObject *_wrap_BossAdministrator
5577		try {
5578		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5579
5580	+	}catch (const BossSchedFailure & e) {
5581	+	PyErr_SetString ( SchedulerError, e.what() );
5582	+	return NULL;
5583		}catch (const std::exception& e) {
5584	<	SWIG_exception(SWIG_RuntimeError, e.what());
5584	>	PyErr_SetString ( BossError, e.what() );
5585	>	return NULL;
5586		}
5587		}
5588		resultobj = PyInt_FromLong((long)result);
#	Line 4644 | Line 5615 | static PyObject *_wrap_BossAdministrator
5615		try {
5616		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5617
5618	+	}catch (const BossSchedFailure & e) {
5619	+	PyErr_SetString ( SchedulerError, e.what() );
5620	+	return NULL;
5621		}catch (const std::exception& e) {
5622	<	SWIG_exception(SWIG_RuntimeError, e.what());
5622	>	PyErr_SetString ( BossError, e.what() );
5623	>	return NULL;
5624		}
5625		}
5626		resultobj = PyInt_FromLong((long)result);
#	Line 4710 | Line 5685 | static PyObject *_wrap_BossAdministrator
5685		try {
5686		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5687
5688	+	}catch (const BossSchedFailure & e) {
5689	+	PyErr_SetString ( SchedulerError, e.what() );
5690	+	return NULL;
5691		}catch (const std::exception& e) {
5692	<	SWIG_exception(SWIG_RuntimeError, e.what());
5692	>	PyErr_SetString ( BossError, e.what() );
5693	>	return NULL;
5694		}
5695		}
5696		resultobj = PyInt_FromLong((long)result);
#	Line 4800 | Line 5779 | static PyObject *_wrap_BossAdministrator
5779		try {
5780		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5781
5782	+	}catch (const BossSchedFailure & e) {
5783	+	PyErr_SetString ( SchedulerError, e.what() );
5784	+	return NULL;
5785		}catch (const std::exception& e) {
5786	<	SWIG_exception(SWIG_RuntimeError, e.what());
5786	>	PyErr_SetString ( BossError, e.what() );
5787	>	return NULL;
5788		}
5789		}
5790		resultobj = PyInt_FromLong((long)result);
#	Line 4876 | Line 5859 | static PyObject *_wrap_BossAdministrator
5859		try {
5860		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5861
5862	+	}catch (const BossSchedFailure & e) {
5863	+	PyErr_SetString ( SchedulerError, e.what() );
5864	+	return NULL;
5865		}catch (const std::exception& e) {
5866	<	SWIG_exception(SWIG_RuntimeError, e.what());
5866	>	PyErr_SetString ( BossError, e.what() );
5867	>	return NULL;
5868		}
5869		}
5870		resultobj = PyInt_FromLong((long)result);
#	Line 4905 | Line 5892 | static PyObject *_wrap_BossAdministrator
5892		std::string arg13 = (std::string) "" ;
5893		bool arg14 = (bool) false ;
5894		bool arg15 = (bool) false ;
5895	+	bool arg16 = (bool) false ;
5896	+	bool arg17 = (bool) false ;
5897		int result;
5898		std::string temp2 ;
5899		std::string temp11 ;
#	Line 4923 | Line 5912 | static PyObject *_wrap_BossAdministrator
5912		PyObject * obj12 = 0 ;
5913		PyObject * obj13 = 0 ;
5914		PyObject * obj14 = 0 ;
5915	+	PyObject * obj15 = 0 ;
5916	+	PyObject * obj16 = 0 ;
5917
5918	<	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;
5918	>	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;
5919		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5920		{
5921		if (PyString_Check(obj1)) {
#	Line 5032 | Line 6023 | static PyObject *_wrap_BossAdministrator
6023		arg15 = PyInt_AsLong(obj14) ? true : false;
6024		if (PyErr_Occurred()) SWIG_fail;
6025		}
6026	+	if (obj15) {
6027	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6028	+	if (PyErr_Occurred()) SWIG_fail;
6029	+	}
6030	+	if (obj16) {
6031	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6032	+	if (PyErr_Occurred()) SWIG_fail;
6033	+	}
6034		{
6035		try {
6036	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
6036	>	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);
6037
6038	+	}catch (const BossSchedFailure & e) {
6039	+	PyErr_SetString ( SchedulerError, e.what() );
6040	+	return NULL;
6041		}catch (const std::exception& e) {
6042	<	SWIG_exception(SWIG_RuntimeError, e.what());
6042	>	PyErr_SetString ( BossError, e.what() );
6043	>	return NULL;
6044		}
6045		}
6046		resultobj = PyInt_FromLong((long)result);
#	Line 5059 | Line 6062 | static PyObject *_wrap_BossAdministrator
6062		try {
6063		result = (arg1)->help();
6064
6065	+	}catch (const BossSchedFailure & e) {
6066	+	PyErr_SetString ( SchedulerError, e.what() );
6067	+	return NULL;
6068		}catch (const std::exception& e) {
6069	<	SWIG_exception(SWIG_RuntimeError, e.what());
6069	>	PyErr_SetString ( BossError, e.what() );
6070	>	return NULL;
6071		}
6072		}
6073		{
#	Line 5072 | Line 6079 | static PyObject *_wrap_BossAdministrator
6079		}
6080
6081
6082	<	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
6082	>	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
6083		PyObject *resultobj;
6084		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6085	<	std::string *arg2 = 0 ;
6085	>	std::string arg2 ;
6086	>	bool arg3 = (bool) false ;
6087		std::string result;
6088		PyObject * obj0 = 0 ;
6089		PyObject * obj1 = 0 ;
6090	+	PyObject * obj2 = 0 ;
6091
6092	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureDB",&obj0,&obj1)) goto fail;
6092	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
6093		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6094	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6095	<	if (arg2 == NULL) {
6096	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
6094	>	{
6095	>	if (PyString_Check(obj1))
6096	>	arg2 = std::string(PyString_AsString(obj1));
6097	>	else
6098	>	SWIG_exception(SWIG_TypeError, "string expected");
6099	>	}
6100	>	if (obj2) {
6101	>	arg3 = PyInt_AsLong(obj2) ? true : false;
6102	>	if (PyErr_Occurred()) SWIG_fail;
6103		}
6104		{
6105		try {
6106	<	result = (arg1)->configureDB(*arg2);
6106	>	result = (arg1)->SQL(arg2,arg3);
6107
6108	+	}catch (const BossSchedFailure & e) {
6109	+	PyErr_SetString ( SchedulerError, e.what() );
6110	+	return NULL;
6111		}catch (const std::exception& e) {
6112	<	SWIG_exception(SWIG_RuntimeError, e.what());
6112	>	PyErr_SetString ( BossError, e.what() );
6113	>	return NULL;
6114		}
6115		}
6116		{
#	Line 5103 | Line 6122 | static PyObject *_wrap_BossAdministrator
6122		}
6123
6124
6125	<	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
6125	>	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
6126		PyObject *resultobj;
6127		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6128		std::string *arg2 = 0 ;
6129	<	bool arg3 = (bool) false ;
6130	<	std::string result;
6129	>	std::string *arg3 = 0 ;
6130	>	std::string *arg4 = 0 ;
6131	>	std::string const &arg5_defvalue = "0" ;
6132	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
6133	>	int result;
6134	>	std::string temp2 ;
6135	>	std::string temp3 ;
6136	>	std::string temp4 ;
6137	>	std::string temp5 ;
6138		PyObject * obj0 = 0 ;
6139		PyObject * obj1 = 0 ;
6140		PyObject * obj2 = 0 ;
6141	+	PyObject * obj3 = 0 ;
6142	+	PyObject * obj4 = 0 ;
6143
6144	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
6144	>	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6145		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6146	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6147	<	if (arg2 == NULL) {
6148	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
6146	>	{
6147	>	if (PyString_Check(obj1)) {
6148	>	temp2 = std::string(PyString_AsString(obj1));
6149	>	arg2 = &temp2;
6150	>	}else {
6151	>	SWIG_exception(SWIG_TypeError, "string expected");
6152	>	}
6153		}
6154	<	if (obj2) {
6155	<	arg3 = PyInt_AsLong(obj2) ? true : false;
6156	<	if (PyErr_Occurred()) SWIG_fail;
6154	>	{
6155	>	if (PyString_Check(obj2)) {
6156	>	temp3 = std::string(PyString_AsString(obj2));
6157	>	arg3 = &temp3;
6158	>	}else {
6159	>	SWIG_exception(SWIG_TypeError, "string expected");
6160	>	}
6161	>	}
6162	>	{
6163	>	if (PyString_Check(obj3)) {
6164	>	temp4 = std::string(PyString_AsString(obj3));
6165	>	arg4 = &temp4;
6166	>	}else {
6167	>	SWIG_exception(SWIG_TypeError, "string expected");
6168	>	}
6169	>	}
6170	>	if (obj4) {
6171	>	{
6172	>	if (PyString_Check(obj4)) {
6173	>	temp5 = std::string(PyString_AsString(obj4));
6174	>	arg5 = &temp5;
6175	>	}else {
6176	>	SWIG_exception(SWIG_TypeError, "string expected");
6177	>	}
6178	>	}
6179		}
6180		{
6181		try {
6182	<	result = (arg1)->SQL(*arg2,arg3);
6182	>	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6183
6184	+	}catch (const BossSchedFailure & e) {
6185	+	PyErr_SetString ( SchedulerError, e.what() );
6186	+	return NULL;
6187		}catch (const std::exception& e) {
6188	<	SWIG_exception(SWIG_RuntimeError, e.what());
6188	>	PyErr_SetString ( BossError, e.what() );
6189	>	return NULL;
6190		}
6191		}
6192	<	{
5135	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5136	<	}
6192	>	resultobj = PyInt_FromLong((long)result);
6193		return resultobj;
6194		fail:
6195		return NULL;
6196		}
6197
6198
6199	<	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
6199	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
6200		PyObject *resultobj;
6201		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6202	<	std::string *arg2 = 0 ;
6203	<	std::string result;
6202	>	std::string arg2 ;
6203	>	int result;
6204		PyObject * obj0 = 0 ;
6205		PyObject * obj1 = 0 ;
6206
6207	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_purge",&obj0,&obj1)) goto fail;
6207	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
6208		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6209	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6210	<	if (arg2 == NULL) {
6211	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
6209	>	{
6210	>	if (PyString_Check(obj1))
6211	>	arg2 = std::string(PyString_AsString(obj1));
6212	>	else
6213	>	SWIG_exception(SWIG_TypeError, "string expected");
6214		}
6215		{
6216		try {
6217	<	result = (arg1)->purge(*arg2);
6217	>	result = (int)(arg1)->registerPlugins(arg2);
6218
6219	+	}catch (const BossSchedFailure & e) {
6220	+	PyErr_SetString ( SchedulerError, e.what() );
6221	+	return NULL;
6222		}catch (const std::exception& e) {
6223	<	SWIG_exception(SWIG_RuntimeError, e.what());
6223	>	PyErr_SetString ( BossError, e.what() );
6224	>	return NULL;
6225		}
6226		}
6227	<	{
5166	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5167	<	}
6227	>	resultobj = PyInt_FromLong((long)result);
6228		return resultobj;
6229		fail:
6230		return NULL;
#	Line 5194 | Line 6254 | static PyMethodDef SwigMethods[] = {
6254		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
6255		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
6256		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
6257	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6258	<	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6259	<	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6260	<	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6261	<	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6262	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6257	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
6258	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
6259	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
6260	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
6261	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
6262	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
6263	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
6264	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
6265	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
6266	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
6267	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
6268	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6269	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6270	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
6271		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6272		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6273	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6274	+	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6275		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6276		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6277	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6278	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6279	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6280	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6281		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6282		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6283		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5211 | Line 6285 | static PyMethodDef SwigMethods[] = {
6285		{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
6286		{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
6287		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
5214	–	{ (char *)"BossSession_purgeTasks", _wrap_BossSession_purgeTasks, METH_VARARGS },
6288		{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6289		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6290	<	{ (char *)"BossSession_jobQuery", _wrap_BossSession_jobQuery, METH_VARARGS },
5218	<	{ (char *)"BossSession_queryPrint", _wrap_BossSession_queryPrint, METH_VARARGS },
6290	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6291		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6292	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6293	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6294	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6295	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6296	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6297	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6298	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6299	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6300		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6301		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6302		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 5224 | Line 6304 | static PyMethodDef SwigMethods[] = {
6304		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6305		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6306		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5227	–	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5228	–	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5229	–	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5230	–	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5231	–	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6307		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6308		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6309		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
6310		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
6311	<	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6311	>	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6312		{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6313		{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
6314	<	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6314	>	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
6315	>	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6316		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6317	+	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6318		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
6319		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
6320		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
5244	–	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6321		{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
6322		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6323		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6324		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
6325	+	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6326		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6327		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6328		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6329	<	{ (char *)"BossTask_prompt", _wrap_BossTask_prompt, METH_VARARGS },
6329	>	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6330	>	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6331	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6332	>	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6333	>	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6334		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
6335		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6336		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
6337	+	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
6338		{ (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
6339		{ (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
6340		{ (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
#	Line 5263 | Line 6345 | static PyMethodDef SwigMethods[] = {
6345		{ (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
6346		{ (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
6347		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
5266	–	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
6348		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
6349		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
6350	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
6351		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
6352		{ NULL, NULL }
6353		};
#	Line 5273 | Line 6355 | static PyMethodDef SwigMethods[] = {
6355
6356		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6357
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}};
5278	–	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}};
6358		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6359	+	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}};
6360	+	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}};
6361	+	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}};
6362		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}};
6363		static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6364		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6365		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
5284	–	static swig_type_info _swigt__p_std__string[] = {{"_p_std__string", 0, "std::string *", 0},{"_p_std__string"},{0}};
5285	–	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6366		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6367	<	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6367	>	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6368		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6369	+	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6370		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6371		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}};
6372		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}};
6373		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}};
6374		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}};
6375		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}};
6376	+	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6377
6378		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,
5300	–	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6379		_swigt__p_XMLDoc,
6380	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6381	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6382	+	_swigt__p_std__vectorTBossTask_p_t,
6383		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6384		_swigt__p_std__ostream,
6385		_swigt__p_BossTask,
6386		_swigt__p_BossTaskException,
5306	–	_swigt__p_std__string,
5307	–	_swigt__p_BossAttributeContainer,
6387		_swigt__p_printOption,
6388	<	_swigt__p_BossDatabase,
6388	>	_swigt__p_BossAttributeContainer,
6389		_swigt__p_BossJob,
6390	+	_swigt__p_BossDatabase,
6391		_swigt__p_BossSession,
6392		_swigt__p_std__vectorTstd__string_t,
6393		_swigt__p_std__mapTstd__string_std__string_t,
6394		_swigt__p_BossAdministratorSession,
5315	–	_swigt__p_jobStates,
6395		_swigt__p_std__vectorTBossJob_p_t__const_iterator,
6396		_swigt__p_BossTask__job_iterator,
6397	+	_swigt__p_jobStates,
6398		0
6399		};
6400
#	Line 5357 | Line 6437 | SWIGEXPORT(void) SWIG_init(void) {
6437		}
6438		SWIG_InstallConstants(d,swig_const_table);
6439
6440	+
6441	+	// define custom exceptions
6442	+	PyObject *e;
6443	+	e = Py_InitModule("BossSession", NULL);
6444	+	// generic BOSS exception
6445	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
6446	+	Py_INCREF(BossError);
6447	+	PyModule_AddObject(e, "BossError", BossError);
6448	+	// scheduler interaction BOSS exception
6449	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
6450	+	Py_INCREF(SchedulerError);
6451	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
6452	+
6453		}
6454

Diff Legend

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