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.6 by gcodispo, Fri Oct 27 12:45:31 2006 UTC vs.
Revision 1.21 by gcodispo, Tue Feb 20 09:57:08 2007 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_BossAttributeContainer swig_types[8]
666	<	#define  SWIGTYPE_p_printOption swig_types[9]
667	<	#define  SWIGTYPE_p_BossDatabase swig_types[10]
668	<	#define  SWIGTYPE_p_BossJob swig_types[11]
665	>	#define  SWIGTYPE_p_printOption swig_types[8]
666	>	#define  SWIGTYPE_p_BossAttributeContainer swig_types[9]
667	>	#define  SWIGTYPE_p_BossJob swig_types[10]
668	>	#define  SWIGTYPE_p_BossDatabase swig_types[11]
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_jobStates swig_types[16]
674	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[17]
675	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[18]
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) -------- */
#	Line 851 | 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 862 | 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 872 | 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_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){
960	>	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,unsigned int timeout,bool keepfile){
961	>	std::vector<std::string> my_vec = self->listMatch( scheduler,
962	>	schclassad,
963	>	keepfile,
964	>	taskid,
965	>	jobid,
966	>	timeout);
967	>	return BossSession_show( self, my_vec );
968	>	}
969	>	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,unsigned int timeout,bool avoidCheck){
970		if ( !avoidCheck ) {
971		self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
972	<	type, user, after, before);
972	>	type, user, after, before, timeout );
973		}
974		PyObject * job_dict = PyList_New(0);
975		std::vector <std::string>
#	Line 900 | Line 978 | PyObject *BossSession_queryTasks(BossSes
978		it!= taskList.end(); ++it ) {
979		PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
980		}
903	–
904	–	//       int size = taskList.size();
905	–	//       PyObject * job_dict = PyList_New(0);
906	–	//       for ( unsigned int i = 0; i < size; ++i ) {
907	–	//      PyList_SetItem(job_dict,i, );
908	–	//      self->makeBossTask( *it );
909	–	//       }
981		return  job_dict;
982		}
983		PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
#	Line 946 | Line 1017 | PyObject *BossTask_jobDict(BossTask cons
1017		}
1018		return job_dict;
1019		}
1020	<	PyObject *BossTask_jobsMap__SWIG_1(BossTask const *self){
1020	>	PyObject *BossTask_jobsDict(BossTask *self){
1021
1022		PyObject * job_dict = PyDict_New();
1023	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1024		for (BossTask::job_iterator jit = self->job_begin ();
1025		jit != self->job_end (); ++jit) {
1026		std::string id = (*jit)->chainId();
#	Line 1017 | Line 1089 | static PyObject *_wrap_new_objectMap__SW
1089		try {
1090		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1091
1092	+	}catch (const BossSchedFailure & e) {
1093	+	PyErr_SetString ( SchedulerError, e.what() );
1094	+	return NULL;
1095		}catch (const std::exception& e) {
1096	<	SWIG_exception(SWIG_RuntimeError, e.what());
1096	>	PyErr_SetString ( BossError, e.what() );
1097	>	return NULL;
1098		}
1099		}
1100		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1076 | Line 1152 | static PyObject *_wrap_new_objectMap__SW
1152		try {
1153		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1154
1155	+	}catch (const BossSchedFailure & e) {
1156	+	PyErr_SetString ( SchedulerError, e.what() );
1157	+	return NULL;
1158		}catch (const std::exception& e) {
1159	<	SWIG_exception(SWIG_RuntimeError, e.what());
1159	>	PyErr_SetString ( BossError, e.what() );
1160	>	return NULL;
1161		}
1162		}
1163		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1191 | Line 1271 | static PyObject *_wrap_objectMap___len__
1271		try {
1272		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1273
1274	+	}catch (const BossSchedFailure & e) {
1275	+	PyErr_SetString ( SchedulerError, e.what() );
1276	+	return NULL;
1277		}catch (const std::exception& e) {
1278	<	SWIG_exception(SWIG_RuntimeError, e.what());
1278	>	PyErr_SetString ( BossError, e.what() );
1279	>	return NULL;
1280		}
1281		}
1282		resultobj = PyInt_FromLong((long)result);
#	Line 1213 | Line 1297 | static PyObject *_wrap_objectMap_clear(P
1297		try {
1298		(arg1)->clear();
1299
1300	+	}catch (const BossSchedFailure & e) {
1301	+	PyErr_SetString ( SchedulerError, e.what() );
1302	+	return NULL;
1303		}catch (const std::exception& e) {
1304	<	SWIG_exception(SWIG_RuntimeError, e.what());
1304	>	PyErr_SetString ( BossError, e.what() );
1305	>	return NULL;
1306		}
1307		}
1308		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1236 | Line 1324 | static PyObject *_wrap_objectMap___nonze
1324		try {
1325		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1326
1327	+	}catch (const BossSchedFailure & e) {
1328	+	PyErr_SetString ( SchedulerError, e.what() );
1329	+	return NULL;
1330		}catch (const std::exception& e) {
1331	<	SWIG_exception(SWIG_RuntimeError, e.what());
1331	>	PyErr_SetString ( BossError, e.what() );
1332	>	return NULL;
1333		}
1334		}
1335		resultobj = PyInt_FromLong((long)result);
#	Line 1308 | Line 1400 | static PyObject *_wrap_objectMap___setit
1400		try {
1401		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1402
1403	+	}catch (const BossSchedFailure & e) {
1404	+	PyErr_SetString ( SchedulerError, e.what() );
1405	+	return NULL;
1406		}catch (const std::exception& e) {
1407	<	SWIG_exception(SWIG_RuntimeError, e.what());
1407	>	PyErr_SetString ( BossError, e.what() );
1408	>	return NULL;
1409		}
1410		}
1411		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1370 | Line 1466 | static PyObject *_wrap_objectMap_has_key
1466		try {
1467		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1468
1469	+	}catch (const BossSchedFailure & e) {
1470	+	PyErr_SetString ( SchedulerError, e.what() );
1471	+	return NULL;
1472		}catch (const std::exception& e) {
1473	<	SWIG_exception(SWIG_RuntimeError, e.what());
1473	>	PyErr_SetString ( BossError, e.what() );
1474	>	return NULL;
1475		}
1476		}
1477		resultobj = PyInt_FromLong((long)result);
#	Line 1393 | Line 1493 | static PyObject *_wrap_objectMap_keys(Py
1493		try {
1494		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1495
1496	+	}catch (const BossSchedFailure & e) {
1497	+	PyErr_SetString ( SchedulerError, e.what() );
1498	+	return NULL;
1499		}catch (const std::exception& e) {
1500	<	SWIG_exception(SWIG_RuntimeError, e.what());
1500	>	PyErr_SetString ( BossError, e.what() );
1501	>	return NULL;
1502		}
1503		}
1504		resultobj = result;
#	Line 1416 | Line 1520 | static PyObject *_wrap_objectMap_values(
1520		try {
1521		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1522
1523	+	}catch (const BossSchedFailure & e) {
1524	+	PyErr_SetString ( SchedulerError, e.what() );
1525	+	return NULL;
1526		}catch (const std::exception& e) {
1527	<	SWIG_exception(SWIG_RuntimeError, e.what());
1527	>	PyErr_SetString ( BossError, e.what() );
1528	>	return NULL;
1529		}
1530		}
1531		resultobj = result;
#	Line 1439 | Line 1547 | static PyObject *_wrap_objectMap_items(P
1547		try {
1548		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1549
1550	+	}catch (const BossSchedFailure & e) {
1551	+	PyErr_SetString ( SchedulerError, e.what() );
1552	+	return NULL;
1553		}catch (const std::exception& e) {
1554	<	SWIG_exception(SWIG_RuntimeError, e.what());
1554	>	PyErr_SetString ( BossError, e.what() );
1555	>	return NULL;
1556		}
1557		}
1558		resultobj = result;
#	Line 1470 | Line 1582 | static PyObject *_wrap_objectMap___conta
1582		try {
1583		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1584
1585	+	}catch (const BossSchedFailure & e) {
1586	+	PyErr_SetString ( SchedulerError, e.what() );
1587	+	return NULL;
1588		}catch (const std::exception& e) {
1589	<	SWIG_exception(SWIG_RuntimeError, e.what());
1589	>	PyErr_SetString ( BossError, e.what() );
1590	>	return NULL;
1591		}
1592		}
1593		resultobj = PyInt_FromLong((long)result);
#	Line 1516 | Line 1632 | static PyObject *_wrap_delete_objectMap(
1632		try {
1633		delete arg1;
1634
1635	+	}catch (const BossSchedFailure & e) {
1636	+	PyErr_SetString ( SchedulerError, e.what() );
1637	+	return NULL;
1638		}catch (const std::exception& e) {
1639	<	SWIG_exception(SWIG_RuntimeError, e.what());
1639	>	PyErr_SetString ( BossError, e.what() );
1640	>	return NULL;
1641		}
1642		}
1643		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1534 | Line 1654 | static PyObject * objectMap_swigregister
1654		Py_INCREF(obj);
1655		return Py_BuildValue((char *)"");
1656		}
1657	<	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
1657	>	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1658		PyObject *resultobj;
1659	<	BossSession *arg1 = (BossSession *) 0 ;
1660	<	std::vector<std::string > *arg2 = 0 ;
1661	<	PyObject *result;
1659	>	unsigned int arg1 = (unsigned int) 0 ;
1660	>	std::vector<std::string > *result;
1661	>	PyObject * obj0 = 0 ;
1662	>
1663	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1664	>	if (obj0) {
1665	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1666	>	if (PyErr_Occurred()) SWIG_fail;
1667	>	}
1668	>	{
1669	>	try {
1670	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1671	>
1672	>	}catch (const BossSchedFailure & e) {
1673	>	PyErr_SetString ( SchedulerError, e.what() );
1674	>	return NULL;
1675	>	}catch (const std::exception& e) {
1676	>	PyErr_SetString ( BossError, e.what() );
1677	>	return NULL;
1678	>	}
1679	>	}
1680	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1681	>	return resultobj;
1682	>	fail:
1683	>	return NULL;
1684	>	}
1685	>
1686	>
1687	>	static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1688	>	PyObject *resultobj;
1689	>	unsigned int arg1 ;
1690	>	std::string *arg2 = 0 ;
1691	>	std::vector<std::string > *result;
1692	>	std::string temp2 ;
1693		PyObject * obj0 = 0 ;
1694		PyObject * obj1 = 0 ;
1695
1696	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
1697	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1698	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1699	<	if (arg2 == NULL) {
1700	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
1696	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1697	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1698	>	if (PyErr_Occurred()) SWIG_fail;
1699	>	{
1700	>	if (PyString_Check(obj1)) {
1701	>	temp2 = std::string(PyString_AsString(obj1));
1702	>	arg2 = &temp2;
1703	>	}else {
1704	>	SWIG_exception(SWIG_TypeError, "string expected");
1705	>	}
1706		}
1707		{
1708		try {
1709	<	result = (PyObject *)BossSession_show(arg1,*arg2);
1709	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1710
1711	+	}catch (const BossSchedFailure & e) {
1712	+	PyErr_SetString ( SchedulerError, e.what() );
1713	+	return NULL;
1714		}catch (const std::exception& e) {
1715	<	SWIG_exception(SWIG_RuntimeError, e.what());
1715	>	PyErr_SetString ( BossError, e.what() );
1716	>	return NULL;
1717		}
1718		}
1719	<	resultobj = result;
1719	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1720		return resultobj;
1721		fail:
1722		return NULL;
1723		}
1724
1725
1726	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_1(PyObject *self, PyObject *args) {
1726	>	static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1727		PyObject *resultobj;
1728	<	BossSession *arg1 = (BossSession *) 0 ;
1729	<	PyObject *result;
1728	>	std::vector<std::string > *arg1 = 0 ;
1729	>	std::vector<std::string > *result;
1730	>	std::vector<std::string > temp1 ;
1731	>	std::vector<std::string > *v1 ;
1732		PyObject * obj0 = 0 ;
1733
1734	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
1735	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1734	>	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1735	>	{
1736	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1737	>	unsigned int size = (PyTuple_Check(obj0) ?
1738	>	PyTuple_Size(obj0) :
1739	>	PyList_Size(obj0));
1740	>	temp1 = std::vector<std::string >(size);
1741	>	arg1 = &temp1;
1742	>	for (unsigned int i=0; i<size; i++) {
1743	>	PyObject* o = PySequence_GetItem(obj0,i);
1744	>	if (PyString_Check(o)) {
1745	>	temp1[i] = (std::string)(\
1746	>	SwigString_AsString(o));
1747	>	Py_DECREF(o);
1748	>	}else {
1749	>	Py_DECREF(o);
1750	>	PyErr_SetString(PyExc_TypeError,
1751	>	"vector<""std::string""> expected");
1752	>	SWIG_fail;
1753	>	}
1754	>	}
1755	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1756	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1757	>	arg1 = v1;
1758	>	}else {
1759	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1760	>	SWIG_fail;
1761	>	}
1762	>	}
1763		{
1764		try {
1765	<	result = (PyObject *)BossSession_showCHTools__SWIG_1(arg1);
1765	>	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1766
1767	+	}catch (const BossSchedFailure & e) {
1768	+	PyErr_SetString ( SchedulerError, e.what() );
1769	+	return NULL;
1770		}catch (const std::exception& e) {
1771	<	SWIG_exception(SWIG_RuntimeError, e.what());
1771	>	PyErr_SetString ( BossError, e.what() );
1772	>	return NULL;
1773		}
1774		}
1775	<	resultobj = result;
1775	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1776		return resultobj;
1777		fail:
1778		return NULL;
1779		}
1780
1781
1782	<	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
1782	>	static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1783		int argc;
1784	<	PyObject *argv[2];
1784	>	PyObject *argv[3];
1785		int ii;
1786
1787		argc = PyObject_Length(args);
1788	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1788	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1789		argv[ii] = PyTuple_GetItem(args,ii);
1790		}
1791	+	if ((argc >= 0) && (argc <= 1)) {
1792	+	int _v;
1793	+	if (argc <= 0) {
1794	+	return _wrap_new_vector_string__SWIG_0(self,args);
1795	+	}
1796	+	{
1797	+	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1798	+	}
1799	+	if (_v) {
1800	+	return _wrap_new_vector_string__SWIG_0(self,args);
1801	+	}
1802	+	}
1803		if (argc == 1) {
1804		int _v;
1805		{
1806	<	void *ptr;
1807	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1808	<	_v = 0;
1809	<	PyErr_Clear();
1806	>	/* native sequence? */
1807	>	if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1808	>	unsigned int size = (PyTuple_Check(argv[0]) ?
1809	>	PyTuple_Size(argv[0]) :
1810	>	PyList_Size(argv[0]));
1811	>	if (size == 0) {
1812	>	/* an empty sequence can be of any type */
1813	>	_v = 1;
1814	>	}else {
1815	>	/* check the first element only */
1816	>	PyObject* o = PySequence_GetItem(argv[0],0);
1817	>	if (PyString_Check(o))
1818	>	_v = 1;
1819	>	else
1820	>	_v = 0;
1821	>	Py_DECREF(o);
1822	>	}
1823		}else {
1824	+	/* wrapped vector? */
1825	+	std::vector<std::string >* v;
1826	+	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1827	+	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1828		_v = 1;
1829	+	else
1830	+	_v = 0;
1831		}
1832		}
1833		if (_v) {
1834	<	return _wrap_BossSession_showCHTools__SWIG_1(self,args);
1834	>	return _wrap_new_vector_string__SWIG_2(self,args);
1835	>	}
1836	>	}
1837	>	if (argc == 2) {
1838	>	int _v;
1839	>	{
1840	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1841	>	}
1842	>	if (_v) {
1843	>	{
1844	>	_v = PyString_Check(argv[1]) ? 1 : 0;
1845	>	}
1846	>	if (_v) {
1847	>	return _wrap_new_vector_string__SWIG_1(self,args);
1848	>	}
1849		}
1850		}
1851
1852	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showCHTools'");
1852	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1853		return NULL;
1854		}
1855
1856
1857	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_1(PyObject *self, PyObject *args) {
1857	>	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1858		PyObject *resultobj;
1859	<	BossSession *arg1 = (BossSession *) 0 ;
1860	<	PyObject *result;
1859	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1860	>	unsigned int result;
1861	>	std::vector<std::string > temp1 ;
1862	>	std::vector<std::string > *v1 ;
1863		PyObject * obj0 = 0 ;
1864
1865	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
1866	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1865	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1866	>	{
1867	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1868	>	unsigned int size = (PyTuple_Check(obj0) ?
1869	>	PyTuple_Size(obj0) :
1870	>	PyList_Size(obj0));
1871	>	temp1 = std::vector<std::string >(size);
1872	>	arg1 = &temp1;
1873	>	for (unsigned int i=0; i<size; i++) {
1874	>	PyObject* o = PySequence_GetItem(obj0,i);
1875	>	if (PyString_Check(o)) {
1876	>	temp1[i] = (std::string)(\
1877	>	SwigString_AsString(o));
1878	>	Py_DECREF(o);
1879	>	}else {
1880	>	Py_DECREF(o);
1881	>	PyErr_SetString(PyExc_TypeError,
1882	>	"vector<""std::string""> expected");
1883	>	SWIG_fail;
1884	>	}
1885	>	}
1886	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1887	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1888	>	arg1 = v1;
1889	>	}else {
1890	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1891	>	SWIG_fail;
1892	>	}
1893	>	}
1894		{
1895		try {
1896	<	result = (PyObject *)BossSession_showProgramTypes__SWIG_1(arg1);
1896	>	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1897
1898	+	}catch (const BossSchedFailure & e) {
1899	+	PyErr_SetString ( SchedulerError, e.what() );
1900	+	return NULL;
1901		}catch (const std::exception& e) {
1902	<	SWIG_exception(SWIG_RuntimeError, e.what());
1902	>	PyErr_SetString ( BossError, e.what() );
1903	>	return NULL;
1904		}
1905		}
1906	<	resultobj = result;
1906	>	resultobj = PyInt_FromLong((long)result);
1907		return resultobj;
1908		fail:
1909		return NULL;
1910		}
1911
1912
1913	<	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
1914	<	int argc;
1915	<	PyObject *argv[2];
1916	<	int ii;
1913	>	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
1914	>	PyObject *resultobj;
1915	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1916	>	bool result;
1917	>	std::vector<std::string > temp1 ;
1918	>	std::vector<std::string > *v1 ;
1919	>	PyObject * obj0 = 0 ;
1920
1921	<	argc = PyObject_Length(args);
1922	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1923	<	argv[ii] = PyTuple_GetItem(args,ii);
1924	<	}
1925	<	if (argc == 1) {
1926	<	int _v;
1927	<	{
1928	<	void *ptr;
1929	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1930	<	_v = 0;
1931	<	PyErr_Clear();
1932	<	}else {
1933	<	_v = 1;
1921	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
1922	>	{
1923	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1924	>	unsigned int size = (PyTuple_Check(obj0) ?
1925	>	PyTuple_Size(obj0) :
1926	>	PyList_Size(obj0));
1927	>	temp1 = std::vector<std::string >(size);
1928	>	arg1 = &temp1;
1929	>	for (unsigned int i=0; i<size; i++) {
1930	>	PyObject* o = PySequence_GetItem(obj0,i);
1931	>	if (PyString_Check(o)) {
1932	>	temp1[i] = (std::string)(\
1933	>	SwigString_AsString(o));
1934	>	Py_DECREF(o);
1935	>	}else {
1936	>	Py_DECREF(o);
1937	>	PyErr_SetString(PyExc_TypeError,
1938	>	"vector<""std::string""> expected");
1939	>	SWIG_fail;
1940	>	}
1941		}
1942	+	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1943	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1944	+	arg1 = v1;
1945	+	}else {
1946	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1947	+	SWIG_fail;
1948		}
1949	<	if (_v) {
1950	<	return _wrap_BossSession_showProgramTypes__SWIG_1(self,args);
1949	>	}
1950	>	{
1951	>	try {
1952	>	result = (bool)((std::vector<std::string > const *)arg1)->empty();
1953	>
1954	>	}catch (const BossSchedFailure & e) {
1955	>	PyErr_SetString ( SchedulerError, e.what() );
1956	>	return NULL;
1957	>	}catch (const std::exception& e) {
1958	>	PyErr_SetString ( BossError, e.what() );
1959	>	return NULL;
1960		}
1961		}
1962	<
1963	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showProgramTypes'");
1962	>	resultobj = PyInt_FromLong((long)result);
1963	>	return resultobj;
1964	>	fail:
1965		return NULL;
1966		}
1967
1968
1969	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_1(PyObject *self, PyObject *args) {
1969	>	static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
1970		PyObject *resultobj;
1971	<	BossSession *arg1 = (BossSession *) 0 ;
1675	<	PyObject *result;
1971	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1972		PyObject * obj0 = 0 ;
1973
1974	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
1975	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1974	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
1975	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1976		{
1977		try {
1978	<	result = (PyObject *)BossSession_showRTMon__SWIG_1(arg1);
1978	>	(arg1)->clear();
1979
1980	+	}catch (const BossSchedFailure & e) {
1981	+	PyErr_SetString ( SchedulerError, e.what() );
1982	+	return NULL;
1983		}catch (const std::exception& e) {
1984	<	SWIG_exception(SWIG_RuntimeError, e.what());
1984	>	PyErr_SetString ( BossError, e.what() );
1985	>	return NULL;
1986		}
1987		}
1988	<	resultobj = result;
1988	>	Py_INCREF(Py_None); resultobj = Py_None;
1989		return resultobj;
1990		fail:
1991		return NULL;
1992		}
1993
1994
1995	<	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
1996	<	int argc;
1997	<	PyObject *argv[2];
1998	<	int ii;
1995	>	static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
1996	>	PyObject *resultobj;
1997	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1998	>	std::string arg2 ;
1999	>	PyObject * obj0 = 0 ;
2000	>	PyObject * obj1 = 0 ;
2001
2002	<	argc = PyObject_Length(args);
2003	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2004	<	argv[ii] = PyTuple_GetItem(args,ii);
2002	>	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
2003	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2004	>	{
2005	>	if (PyString_Check(obj1))
2006	>	arg2 = std::string(PyString_AsString(obj1));
2007	>	else
2008	>	SWIG_exception(SWIG_TypeError, "string expected");
2009		}
2010	<	if (argc == 1) {
2011	<	int _v;
2012	<	{
2013	<	void *ptr;
2014	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2015	<	_v = 0;
2016	<	PyErr_Clear();
2017	<	}else {
2018	<	_v = 1;
2019	<	}
2010	>	{
2011	>	try {
2012	>	(arg1)->push_back(arg2);
2013	>
2014	>	}catch (const BossSchedFailure & e) {
2015	>	PyErr_SetString ( SchedulerError, e.what() );
2016	>	return NULL;
2017	>	}catch (const std::exception& e) {
2018	>	PyErr_SetString ( BossError, e.what() );
2019	>	return NULL;
2020		}
2021	<	if (_v) {
2022	<	return _wrap_BossSession_showRTMon__SWIG_1(self,args);
2021	>	}
2022	>	Py_INCREF(Py_None); resultobj = Py_None;
2023	>	return resultobj;
2024	>	fail:
2025	>	return NULL;
2026	>	}
2027	>
2028	>
2029	>	static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
2030	>	PyObject *resultobj;
2031	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2032	>	std::string result;
2033	>	PyObject * obj0 = 0 ;
2034	>
2035	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
2036	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2037	>	{
2038	>	try {
2039	>	result = std_vectorlstd_string_g_pop___(arg1);
2040	>
2041	>	}catch (std::out_of_range& e) {
2042	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2043		}
2044		}
2045	+	{
2046	+	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2047	+	}
2048	+	return resultobj;
2049	+	fail:
2050	+	return NULL;
2051	+	}
2052	+
2053	+
2054	+	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
2055	+	PyObject *resultobj;
2056	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2057	+	int arg2 ;
2058	+	std::string result;
2059	+	PyObject * obj0 = 0 ;
2060
2061	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showRTMon'");
2061	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
2062	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2063	>	{
2064	>	try {
2065	>	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
2066	>
2067	>	}catch (std::out_of_range& e) {
2068	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2069	>	}
2070	>	}
2071	>	{
2072	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2073	>	}
2074	>	return resultobj;
2075	>	fail:
2076		return NULL;
2077		}
2078
2079
2080	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_1(PyObject *self, PyObject *args) {
2080	>	static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2081		PyObject *resultobj;
2082	<	BossSession *arg1 = (BossSession *) 0 ;
2083	<	PyObject *result;
2082	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2083	>	int arg2 ;
2084	>	int arg3 ;
2085	>	std::vector<std::string > result;
2086		PyObject * obj0 = 0 ;
2087
2088	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2089	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2088	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2089	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2090		{
2091		try {
2092	<	result = (PyObject *)BossSession_showSchedulers__SWIG_1(arg1);
2092	>	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2093
2094	+	}catch (const BossSchedFailure & e) {
2095	+	PyErr_SetString ( SchedulerError, e.what() );
2096	+	return NULL;
2097		}catch (const std::exception& e) {
2098	<	SWIG_exception(SWIG_RuntimeError, e.what());
2098	>	PyErr_SetString ( BossError, e.what() );
2099	>	return NULL;
2100		}
2101		}
2102	<	resultobj = result;
2102	>	{
2103	>	resultobj = PyTuple_New((&result)->size());
2104	>	for (unsigned int i=0; i<(&result)->size(); i++)
2105	>	PyTuple_SetItem(resultobj,i,
2106	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2107	>	}
2108		return resultobj;
2109		fail:
2110		return NULL;
2111		}
2112
2113
2114	<	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2115	<	int argc;
2116	<	PyObject *argv[2];
2117	<	int ii;
2114	>	static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2115	>	PyObject *resultobj;
2116	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2117	>	int arg2 ;
2118	>	std::string arg3 ;
2119	>	PyObject * obj0 = 0 ;
2120	>	PyObject * obj2 = 0 ;
2121
2122	<	argc = PyObject_Length(args);
2123	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2124	<	argv[ii] = PyTuple_GetItem(args,ii);
2122	>	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2123	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2124	>	{
2125	>	if (PyString_Check(obj2))
2126	>	arg3 = std::string(PyString_AsString(obj2));
2127	>	else
2128	>	SWIG_exception(SWIG_TypeError, "string expected");
2129		}
2130	<	if (argc == 1) {
2131	<	int _v;
2132	<	{
2133	<	void *ptr;
2134	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2135	<	_v = 0;
1763	<	PyErr_Clear();
1764	<	}else {
1765	<	_v = 1;
1766	<	}
1767	<	}
1768	<	if (_v) {
1769	<	return _wrap_BossSession_showSchedulers__SWIG_1(self,args);
2130	>	{
2131	>	try {
2132	>	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2133	>
2134	>	}catch (std::out_of_range& e) {
2135	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2136		}
2137		}
2138	<
2139	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showSchedulers'");
2138	>	Py_INCREF(Py_None); resultobj = Py_None;
2139	>	return resultobj;
2140	>	fail:
2141		return NULL;
2142		}
2143
2144
2145	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
2145	>	static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2146		PyObject *resultobj;
2147	<	BossSession *arg1 = (BossSession *) 0 ;
2148	<	int arg2 = (int) SCHEDULED ;
2149	<	std::string const &arg3_defvalue = "all" ;
2150	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
2151	<	std::string const &arg4_defvalue = "all" ;
2152	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
1786	<	std::string const &arg5_defvalue = "" ;
1787	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
1788	<	std::string arg6 = (std::string) "" ;
1789	<	std::string arg7 = (std::string) "" ;
1790	<	std::string arg8 = (std::string) "" ;
1791	<	std::string arg9 = (std::string) "" ;
1792	<	bool arg10 = (bool) false ;
1793	<	PyObject *result;
1794	<	std::string temp3 ;
1795	<	std::string temp4 ;
1796	<	std::string temp5 ;
2147	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2148	>	int arg2 ;
2149	>	int arg3 ;
2150	>	std::vector<std::string > *arg4 = 0 ;
2151	>	std::vector<std::string > temp4 ;
2152	>	std::vector<std::string > *v4 ;
2153		PyObject * obj0 = 0 ;
1798	–	PyObject * obj2 = 0 ;
2154		PyObject * obj3 = 0 ;
1800	–	PyObject * obj4 = 0 ;
1801	–	PyObject * obj5 = 0 ;
1802	–	PyObject * obj6 = 0 ;
1803	–	PyObject * obj7 = 0 ;
1804	–	PyObject * obj8 = 0 ;
1805	–	PyObject * obj9 = 0 ;
2155
2156	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2157	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2158	<	if (obj2) {
2159	<	{
2160	<	if (PyString_Check(obj2)) {
2161	<	temp3 = std::string(PyString_AsString(obj2));
2162	<	arg3 = &temp3;
2163	<	}else {
2164	<	SWIG_exception(SWIG_TypeError, "string expected");
2156	>	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2157	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2158	>	{
2159	>	if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2160	>	unsigned int size = (PyTuple_Check(obj3) ?
2161	>	PyTuple_Size(obj3) :
2162	>	PyList_Size(obj3));
2163	>	temp4 = std::vector<std::string >(size);
2164	>	arg4 = &temp4;
2165	>	for (unsigned int i=0; i<size; i++) {
2166	>	PyObject* o = PySequence_GetItem(obj3,i);
2167	>	if (PyString_Check(o)) {
2168	>	temp4[i] = (std::string)(\
2169	>	SwigString_AsString(o));
2170	>	Py_DECREF(o);
2171	>	}else {
2172	>	Py_DECREF(o);
2173	>	PyErr_SetString(PyExc_TypeError,
2174	>	"vector<""std::string""> expected");
2175	>	SWIG_fail;
2176	>	}
2177		}
2178	+	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2179	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2180	+	arg4 = v4;
2181	+	}else {
2182	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2183	+	SWIG_fail;
2184		}
2185		}
2186	<	if (obj3) {
2187	<	{
2188	<	if (PyString_Check(obj3)) {
2189	<	temp4 = std::string(PyString_AsString(obj3));
2190	<	arg4 = &temp4;
2191	<	}else {
2192	<	SWIG_exception(SWIG_TypeError, "string expected");
2193	<	}
2186	>	{
2187	>	try {
2188	>	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2189	>
2190	>	}catch (const BossSchedFailure & e) {
2191	>	PyErr_SetString ( SchedulerError, e.what() );
2192	>	return NULL;
2193	>	}catch (const std::exception& e) {
2194	>	PyErr_SetString ( BossError, e.what() );
2195	>	return NULL;
2196		}
2197		}
2198	<	if (obj4) {
2199	<	{
2200	<	if (PyString_Check(obj4)) {
2201	<	temp5 = std::string(PyString_AsString(obj4));
2202	<	arg5 = &temp5;
2203	<	}else {
2204	<	SWIG_exception(SWIG_TypeError, "string expected");
2205	<	}
2198	>	Py_INCREF(Py_None); resultobj = Py_None;
2199	>	return resultobj;
2200	>	fail:
2201	>	return NULL;
2202	>	}
2203	>
2204	>
2205	>	static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2206	>	PyObject *resultobj;
2207	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2208	>	int arg2 ;
2209	>	PyObject * obj0 = 0 ;
2210	>
2211	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2212	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2213	>	{
2214	>	try {
2215	>	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2216	>
2217	>	}catch (std::out_of_range& e) {
2218	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2219		}
2220		}
2221	<	if (obj5) {
2221	>	Py_INCREF(Py_None); resultobj = Py_None;
2222	>	return resultobj;
2223	>	fail:
2224	>	return NULL;
2225	>	}
2226	>
2227	>
2228	>	static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2229	>	PyObject *resultobj;
2230	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2231	>	int arg2 ;
2232	>	int arg3 ;
2233	>	PyObject * obj0 = 0 ;
2234	>
2235	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2236	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2237	>	{
2238	>	try {
2239	>	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2240	>
2241	>	}catch (const BossSchedFailure & e) {
2242	>	PyErr_SetString ( SchedulerError, e.what() );
2243	>	return NULL;
2244	>	}catch (const std::exception& e) {
2245	>	PyErr_SetString ( BossError, e.what() );
2246	>	return NULL;
2247	>	}
2248	>	}
2249	>	Py_INCREF(Py_None); resultobj = Py_None;
2250	>	return resultobj;
2251	>	fail:
2252	>	return NULL;
2253	>	}
2254	>
2255	>
2256	>	static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2257	>	PyObject *resultobj;
2258	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2259	>	PyObject * obj0 = 0 ;
2260	>
2261	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2262	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2263	>	{
2264	>	try {
2265	>	delete arg1;
2266	>
2267	>	}catch (const BossSchedFailure & e) {
2268	>	PyErr_SetString ( SchedulerError, e.what() );
2269	>	return NULL;
2270	>	}catch (const std::exception& e) {
2271	>	PyErr_SetString ( BossError, e.what() );
2272	>	return NULL;
2273	>	}
2274	>	}
2275	>	Py_INCREF(Py_None); resultobj = Py_None;
2276	>	return resultobj;
2277	>	fail:
2278	>	return NULL;
2279	>	}
2280	>
2281	>
2282	>	static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2283	>	PyObject *obj;
2284	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2285	>	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2286	>	Py_INCREF(obj);
2287	>	return Py_BuildValue((char *)"");
2288	>	}
2289	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2290	>	PyObject *resultobj;
2291	>	std::string arg1 = (std::string) "" ;
2292	>	std::string arg2 = (std::string) "2" ;
2293	>	std::string arg3 = (std::string) "" ;
2294	>	std::string arg4 = (std::string) "" ;
2295	>	BossSession *result;
2296	>	PyObject * obj0 = 0 ;
2297	>	PyObject * obj1 = 0 ;
2298	>	PyObject * obj2 = 0 ;
2299	>	PyObject * obj3 = 0 ;
2300	>
2301	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2302	>	if (obj0) {
2303		{
2304	<	if (PyString_Check(obj5))
2305	<	arg6 = std::string(PyString_AsString(obj5));
2304	>	if (PyString_Check(obj0))
2305	>	arg1 = std::string(PyString_AsString(obj0));
2306		else
2307		SWIG_exception(SWIG_TypeError, "string expected");
2308		}
2309		}
2310	<	if (obj6) {
2310	>	if (obj1) {
2311		{
2312	<	if (PyString_Check(obj6))
2313	<	arg7 = std::string(PyString_AsString(obj6));
2312	>	if (PyString_Check(obj1))
2313	>	arg2 = std::string(PyString_AsString(obj1));
2314		else
2315		SWIG_exception(SWIG_TypeError, "string expected");
2316		}
2317		}
2318	<	if (obj7) {
2318	>	if (obj2) {
2319		{
2320	<	if (PyString_Check(obj7))
2321	<	arg8 = std::string(PyString_AsString(obj7));
2320	>	if (PyString_Check(obj2))
2321	>	arg3 = std::string(PyString_AsString(obj2));
2322		else
2323		SWIG_exception(SWIG_TypeError, "string expected");
2324		}
2325		}
2326	<	if (obj8) {
2326	>	if (obj3) {
2327		{
2328	<	if (PyString_Check(obj8))
2329	<	arg9 = std::string(PyString_AsString(obj8));
2328	>	if (PyString_Check(obj3))
2329	>	arg4 = std::string(PyString_AsString(obj3));
2330		else
2331		SWIG_exception(SWIG_TypeError, "string expected");
2332		}
2333		}
1871	–	if (obj9) {
1872	–	arg10 = PyInt_AsLong(obj9) ? true : false;
1873	–	if (PyErr_Occurred()) SWIG_fail;
1874	–	}
2334		{
2335		try {
2336	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2336	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2337
2338	+	}catch (const BossSchedFailure & e) {
2339	+	PyErr_SetString ( SchedulerError, e.what() );
2340	+	return NULL;
2341		}catch (const std::exception& e) {
2342	<	SWIG_exception(SWIG_RuntimeError, e.what());
2342	>	PyErr_SetString ( BossError, e.what() );
2343	>	return NULL;
2344		}
2345		}
2346	<	resultobj = result;
2346	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2347		return resultobj;
2348		fail:
2349		return NULL;
2350		}
2351
2352
2353	<	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2353	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2354		PyObject *resultobj;
2355	<	std::string arg1 = (std::string) "" ;
1893	<	BossSession *result;
2355	>	BossSession *arg1 = (BossSession *) 0 ;
2356		PyObject * obj0 = 0 ;
2357
2358	<	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2359	<	if (obj0) {
1898	<	{
1899	<	if (PyString_Check(obj0))
1900	<	arg1 = std::string(PyString_AsString(obj0));
1901	<	else
1902	<	SWIG_exception(SWIG_TypeError, "string expected");
1903	<	}
1904	<	}
2358	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2359	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2360		{
2361		try {
2362	<	result = (BossSession *)new BossSession(arg1);
2362	>	delete arg1;
2363
2364	+	}catch (const BossSchedFailure & e) {
2365	+	PyErr_SetString ( SchedulerError, e.what() );
2366	+	return NULL;
2367		}catch (const std::exception& e) {
2368	<	SWIG_exception(SWIG_RuntimeError, e.what());
2368	>	PyErr_SetString ( BossError, e.what() );
2369	>	return NULL;
2370		}
2371		}
2372	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2372	>	Py_INCREF(Py_None); resultobj = Py_None;
2373		return resultobj;
2374		fail:
2375		return NULL;
2376		}
2377
2378
2379	<	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2379	>	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2380		PyObject *resultobj;
2381		BossSession *arg1 = (BossSession *) 0 ;
2382		PyObject * obj0 = 0 ;
2383
2384	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2384	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2385		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2386		{
2387		try {
2388	<	delete arg1;
2388	>	(arg1)->resetDB();
2389
2390	+	}catch (const BossSchedFailure & e) {
2391	+	PyErr_SetString ( SchedulerError, e.what() );
2392	+	return NULL;
2393		}catch (const std::exception& e) {
2394	<	SWIG_exception(SWIG_RuntimeError, e.what());
2394	>	PyErr_SetString ( BossError, e.what() );
2395	>	return NULL;
2396		}
2397		}
2398		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1950 | Line 2413 | static PyObject *_wrap_BossSession_clear
2413		try {
2414		(arg1)->clear();
2415
2416	+	}catch (const BossSchedFailure & e) {
2417	+	PyErr_SetString ( SchedulerError, e.what() );
2418	+	return NULL;
2419		}catch (const std::exception& e) {
2420	<	SWIG_exception(SWIG_RuntimeError, e.what());
2420	>	PyErr_SetString ( BossError, e.what() );
2421	>	return NULL;
2422		}
2423		}
2424		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1987 | Line 2454 | static PyObject *_wrap_BossSession_makeB
2454		try {
2455		result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2456
2457	+	}catch (const BossSchedFailure & e) {
2458	+	PyErr_SetString ( SchedulerError, e.what() );
2459	+	return NULL;
2460		}catch (const std::exception& e) {
2461	<	SWIG_exception(SWIG_RuntimeError, e.what());
2461	>	PyErr_SetString ( BossError, e.what() );
2462	>	return NULL;
2463		}
2464		}
2465		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
#	Line 2012 | Line 2483 | static PyObject *_wrap_BossSession_destr
2483		try {
2484		(arg1)->destroyBossTask(arg2);
2485
2486	+	}catch (const BossSchedFailure & e) {
2487	+	PyErr_SetString ( SchedulerError, e.what() );
2488	+	return NULL;
2489		}catch (const std::exception& e) {
2490	<	SWIG_exception(SWIG_RuntimeError, e.what());
2490	>	PyErr_SetString ( BossError, e.what() );
2491	>	return NULL;
2492		}
2493		}
2494		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2023 | Line 2498 | static PyObject *_wrap_BossSession_destr
2498		}
2499
2500
2501	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_0(PyObject *self, PyObject *args) {
2501	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2502		PyObject *resultobj;
2503		BossSession *arg1 = (BossSession *) 0 ;
2504	<	SwigValueWrapper< std::vector<std::string > > result;
2504	>	std::vector<std::string > result;
2505		PyObject * obj0 = 0 ;
2506
2507		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
#	Line 2035 | Line 2510 | static PyObject *_wrap_BossSession_showC
2510		try {
2511		result = (arg1)->showCHTools();
2512
2513	+	}catch (const BossSchedFailure & e) {
2514	+	PyErr_SetString ( SchedulerError, e.what() );
2515	+	return NULL;
2516		}catch (const std::exception& e) {
2517	<	SWIG_exception(SWIG_RuntimeError, e.what());
2517	>	PyErr_SetString ( BossError, e.what() );
2518	>	return NULL;
2519		}
2520		}
2521		{
2522	<	std::vector<std::string > * resultptr;
2523	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2524	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2522	>	resultobj = PyTuple_New((&result)->size());
2523	>	for (unsigned int i=0; i<(&result)->size(); i++)
2524	>	PyTuple_SetItem(resultobj,i,
2525	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2526		}
2527		return resultobj;
2528		fail:
#	Line 2050 | Line 2530 | static PyObject *_wrap_BossSession_showC
2530		}
2531
2532
2533	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_0(PyObject *self, PyObject *args) {
2533	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2534		PyObject *resultobj;
2535		BossSession *arg1 = (BossSession *) 0 ;
2536	<	SwigValueWrapper< std::vector<std::string > > result;
2536	>	std::vector<std::string > result;
2537		PyObject * obj0 = 0 ;
2538
2539		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
#	Line 2062 | Line 2542 | static PyObject *_wrap_BossSession_showP
2542		try {
2543		result = (arg1)->showProgramTypes();
2544
2545	+	}catch (const BossSchedFailure & e) {
2546	+	PyErr_SetString ( SchedulerError, e.what() );
2547	+	return NULL;
2548		}catch (const std::exception& e) {
2549	<	SWIG_exception(SWIG_RuntimeError, e.what());
2549	>	PyErr_SetString ( BossError, e.what() );
2550	>	return NULL;
2551		}
2552		}
2553		{
2554	<	std::vector<std::string > * resultptr;
2555	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2556	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2554	>	resultobj = PyTuple_New((&result)->size());
2555	>	for (unsigned int i=0; i<(&result)->size(); i++)
2556	>	PyTuple_SetItem(resultobj,i,
2557	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2558		}
2559		return resultobj;
2560		fail:
#	Line 2077 | Line 2562 | static PyObject *_wrap_BossSession_showP
2562		}
2563
2564
2565	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_0(PyObject *self, PyObject *args) {
2565	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2566		PyObject *resultobj;
2567		BossSession *arg1 = (BossSession *) 0 ;
2568	<	SwigValueWrapper< std::vector<std::string > > result;
2568	>	std::vector<std::string > result;
2569		PyObject * obj0 = 0 ;
2570
2571		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
#	Line 2089 | Line 2574 | static PyObject *_wrap_BossSession_showR
2574		try {
2575		result = (arg1)->showRTMon();
2576
2577	+	}catch (const BossSchedFailure & e) {
2578	+	PyErr_SetString ( SchedulerError, e.what() );
2579	+	return NULL;
2580		}catch (const std::exception& e) {
2581	<	SWIG_exception(SWIG_RuntimeError, e.what());
2581	>	PyErr_SetString ( BossError, e.what() );
2582	>	return NULL;
2583		}
2584		}
2585		{
2586	<	std::vector<std::string > * resultptr;
2587	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2588	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2586	>	resultobj = PyTuple_New((&result)->size());
2587	>	for (unsigned int i=0; i<(&result)->size(); i++)
2588	>	PyTuple_SetItem(resultobj,i,
2589	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2590		}
2591		return resultobj;
2592		fail:
#	Line 2104 | Line 2594 | static PyObject *_wrap_BossSession_showR
2594		}
2595
2596
2597	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_0(PyObject *self, PyObject *args) {
2597	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2598		PyObject *resultobj;
2599		BossSession *arg1 = (BossSession *) 0 ;
2600	<	SwigValueWrapper< std::vector<std::string > > result;
2600	>	std::vector<std::string > result;
2601		PyObject * obj0 = 0 ;
2602
2603		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
#	Line 2116 | Line 2606 | static PyObject *_wrap_BossSession_showS
2606		try {
2607		result = (arg1)->showSchedulers();
2608
2609	+	}catch (const BossSchedFailure & e) {
2610	+	PyErr_SetString ( SchedulerError, e.what() );
2611	+	return NULL;
2612		}catch (const std::exception& e) {
2613	<	SWIG_exception(SWIG_RuntimeError, e.what());
2613	>	PyErr_SetString ( BossError, e.what() );
2614	>	return NULL;
2615		}
2616		}
2617		{
2618	<	std::vector<std::string > * resultptr;
2619	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2620	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2618	>	resultobj = PyTuple_New((&result)->size());
2619	>	for (unsigned int i=0; i<(&result)->size(); i++)
2620	>	PyTuple_SetItem(resultobj,i,
2621	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2622		}
2623		return resultobj;
2624		fail:
#	Line 2143 | Line 2638 | static PyObject *_wrap_BossSession_defau
2638		try {
2639		result = (arg1)->defaultCHTool();
2640
2641	+	}catch (const BossSchedFailure & e) {
2642	+	PyErr_SetString ( SchedulerError, e.what() );
2643	+	return NULL;
2644		}catch (const std::exception& e) {
2645	<	SWIG_exception(SWIG_RuntimeError, e.what());
2645	>	PyErr_SetString ( BossError, e.what() );
2646	>	return NULL;
2647		}
2648		}
2649		{
#	Line 2168 | Line 2667 | static PyObject *_wrap_BossSession_defau
2667		try {
2668		result = (arg1)->defaultProgramType();
2669
2670	+	}catch (const BossSchedFailure & e) {
2671	+	PyErr_SetString ( SchedulerError, e.what() );
2672	+	return NULL;
2673		}catch (const std::exception& e) {
2674	<	SWIG_exception(SWIG_RuntimeError, e.what());
2674	>	PyErr_SetString ( BossError, e.what() );
2675	>	return NULL;
2676		}
2677		}
2678		{
#	Line 2193 | Line 2696 | static PyObject *_wrap_BossSession_defau
2696		try {
2697		result = (arg1)->defaultRTMon();
2698
2699	+	}catch (const BossSchedFailure & e) {
2700	+	PyErr_SetString ( SchedulerError, e.what() );
2701	+	return NULL;
2702		}catch (const std::exception& e) {
2703	<	SWIG_exception(SWIG_RuntimeError, e.what());
2703	>	PyErr_SetString ( BossError, e.what() );
2704	>	return NULL;
2705		}
2706		}
2707		{
#	Line 2218 | Line 2725 | static PyObject *_wrap_BossSession_defau
2725		try {
2726		result = (arg1)->defaultScheduler();
2727
2728	+	}catch (const BossSchedFailure & e) {
2729	+	PyErr_SetString ( SchedulerError, e.what() );
2730	+	return NULL;
2731		}catch (const std::exception& e) {
2732	<	SWIG_exception(SWIG_RuntimeError, e.what());
2732	>	PyErr_SetString ( BossError, e.what() );
2733	>	return NULL;
2734		}
2735		}
2736		{
#	Line 2243 | Line 2754 | static PyObject *_wrap_BossSession_versi
2754		try {
2755		result = (arg1)->version();
2756
2757	+	}catch (const BossSchedFailure & e) {
2758	+	PyErr_SetString ( SchedulerError, e.what() );
2759	+	return NULL;
2760		}catch (const std::exception& e) {
2761	<	SWIG_exception(SWIG_RuntimeError, e.what());
2761	>	PyErr_SetString ( BossError, e.what() );
2762	>	return NULL;
2763		}
2764		}
2765		{
#	Line 2268 | Line 2783 | static PyObject *_wrap_BossSession_clien
2783		try {
2784		result = (arg1)->clientID();
2785
2786	+	}catch (const BossSchedFailure & e) {
2787	+	PyErr_SetString ( SchedulerError, e.what() );
2788	+	return NULL;
2789		}catch (const std::exception& e) {
2790	<	SWIG_exception(SWIG_RuntimeError, e.what());
2790	>	PyErr_SetString ( BossError, e.what() );
2791	>	return NULL;
2792		}
2793		}
2794		{
#	Line 2299 | Line 2818 | static PyObject *_wrap_BossSession_showC
2818		try {
2819		result = (int)(arg1)->showConfigs(arg2);
2820
2821	+	}catch (const BossSchedFailure & e) {
2822	+	PyErr_SetString ( SchedulerError, e.what() );
2823	+	return NULL;
2824		}catch (const std::exception& e) {
2825	<	SWIG_exception(SWIG_RuntimeError, e.what());
2826	<	}
2305	<	}
2306	<	resultobj = PyInt_FromLong((long)result);
2307	<	return resultobj;
2308	<	fail:
2309	<	return NULL;
2310	<	}
2311	<
2312	<
2313	<	static PyObject *_wrap_BossSession_purgeTasks(PyObject *self, PyObject *args) {
2314	<	PyObject *resultobj;
2315	<	BossSession *arg1 = (BossSession *) 0 ;
2316	<	std::string *arg2 = 0 ;
2317	<	std::string *arg3 = 0 ;
2318	<	std::string *arg4 = 0 ;
2319	<	std::string const &arg5_defvalue = "0" ;
2320	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2321	<	int result;
2322	<	std::string temp2 ;
2323	<	std::string temp3 ;
2324	<	std::string temp4 ;
2325	<	std::string temp5 ;
2326	<	PyObject * obj0 = 0 ;
2327	<	PyObject * obj1 = 0 ;
2328	<	PyObject * obj2 = 0 ;
2329	<	PyObject * obj3 = 0 ;
2330	<	PyObject * obj4 = 0 ;
2331	<
2332	<	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossSession_purgeTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
2333	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2334	<	{
2335	<	if (PyString_Check(obj1)) {
2336	<	temp2 = std::string(PyString_AsString(obj1));
2337	<	arg2 = &temp2;
2338	<	}else {
2339	<	SWIG_exception(SWIG_TypeError, "string expected");
2340	<	}
2341	<	}
2342	<	{
2343	<	if (PyString_Check(obj2)) {
2344	<	temp3 = std::string(PyString_AsString(obj2));
2345	<	arg3 = &temp3;
2346	<	}else {
2347	<	SWIG_exception(SWIG_TypeError, "string expected");
2348	<	}
2349	<	}
2350	<	{
2351	<	if (PyString_Check(obj3)) {
2352	<	temp4 = std::string(PyString_AsString(obj3));
2353	<	arg4 = &temp4;
2354	<	}else {
2355	<	SWIG_exception(SWIG_TypeError, "string expected");
2356	<	}
2357	<	}
2358	<	if (obj4) {
2359	<	{
2360	<	if (PyString_Check(obj4)) {
2361	<	temp5 = std::string(PyString_AsString(obj4));
2362	<	arg5 = &temp5;
2363	<	}else {
2364	<	SWIG_exception(SWIG_TypeError, "string expected");
2365	<	}
2366	<	}
2367	<	}
2368	<	{
2369	<	try {
2370	<	result = (int)(arg1)->purgeTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
2371	<
2372	<	}catch (const std::exception& e) {
2373	<	SWIG_exception(SWIG_RuntimeError, e.what());
2825	>	PyErr_SetString ( BossError, e.what() );
2826	>	return NULL;
2827		}
2828		}
2829		resultobj = PyInt_FromLong((long)result);
#	Line 2422 | Line 2875 | static PyObject *_wrap_BossSession_RTupd
2875		try {
2876		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2877
2878	+	}catch (const BossSchedFailure & e) {
2879	+	PyErr_SetString ( SchedulerError, e.what() );
2880	+	return NULL;
2881		}catch (const std::exception& e) {
2882	<	SWIG_exception(SWIG_RuntimeError, e.what());
2882	>	PyErr_SetString ( BossError, e.what() );
2883	>	return NULL;
2884		}
2885		}
2886		resultobj = PyInt_FromLong((long)result);
#	Line 2443 | Line 2900 | static PyObject *_wrap_BossSession_listM
2900		std::string *arg5 = (std::string *) &arg5_defvalue ;
2901		std::string const &arg6_defvalue = "" ;
2902		std::string *arg6 = (std::string *) &arg6_defvalue ;
2903	<	std::string result;
2903	>	unsigned int arg7 = (unsigned int) 0 ;
2904	>	std::vector<std::string > result;
2905		std::string temp2 ;
2906		std::string temp3 ;
2907		std::string temp5 ;
#	Line 2454 | Line 2912 | static PyObject *_wrap_BossSession_listM
2912		PyObject * obj3 = 0 ;
2913		PyObject * obj4 = 0 ;
2914		PyObject * obj5 = 0 ;
2915	+	PyObject * obj6 = 0 ;
2916
2917	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2917	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2918		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2919		{
2920		if (PyString_Check(obj1)) {
#	Line 2497 | Line 2956 | static PyObject *_wrap_BossSession_listM
2956		}
2957		}
2958		}
2959	+	if (obj6) {
2960	+	arg7 = (unsigned int) PyInt_AsLong(obj6);
2961	+	if (PyErr_Occurred()) SWIG_fail;
2962	+	}
2963		{
2964		try {
2965	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
2965	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
2966
2967	+	}catch (const BossSchedFailure & e) {
2968	+	PyErr_SetString ( SchedulerError, e.what() );
2969	+	return NULL;
2970		}catch (const std::exception& e) {
2971	<	SWIG_exception(SWIG_RuntimeError, e.what());
2971	>	PyErr_SetString ( BossError, e.what() );
2972	>	return NULL;
2973		}
2974		}
2975		{
2976	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2976	>	resultobj = PyTuple_New((&result)->size());
2977	>	for (unsigned int i=0; i<(&result)->size(); i++)
2978	>	PyTuple_SetItem(resultobj,i,
2979	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2980		}
2981		return resultobj;
2982		fail:
#	Line 2528 | Line 2998 | static PyObject *_wrap_BossSession_sched
2998		std::string arg7 = (std::string) "" ;
2999		std::string arg8 = (std::string) "" ;
3000		std::string arg9 = (std::string) "" ;
3001	+	unsigned int arg10 = (unsigned int) 0 ;
3002		std::string temp3 ;
3003		std::string temp4 ;
3004		std::string temp5 ;
#	Line 2539 | Line 3010 | static PyObject *_wrap_BossSession_sched
3010		PyObject * obj6 = 0 ;
3011		PyObject * obj7 = 0 ;
3012		PyObject * obj8 = 0 ;
3013	+	PyObject * obj9 = 0 ;
3014
3015	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3015	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3016		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3017		if (obj2) {
3018		{
#	Line 2604 | Line 3076 | static PyObject *_wrap_BossSession_sched
3076		SWIG_exception(SWIG_TypeError, "string expected");
3077		}
3078		}
3079	+	if (obj9) {
3080	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3081	+	if (PyErr_Occurred()) SWIG_fail;
3082	+	}
3083		{
3084		try {
3085	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3085	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3086
3087	+	}catch (const BossSchedFailure & e) {
3088	+	PyErr_SetString ( SchedulerError, e.what() );
3089	+	return NULL;
3090		}catch (const std::exception& e) {
3091	<	SWIG_exception(SWIG_RuntimeError, e.what());
3091	>	PyErr_SetString ( BossError, e.what() );
3092	>	return NULL;
3093		}
3094		}
3095		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2619 | Line 3099 | static PyObject *_wrap_BossSession_sched
3099		}
3100
3101
3102	<	static PyObject *_wrap_BossSession_queryPrint(PyObject *self, PyObject *args) {
3102	>	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3103		PyObject *resultobj;
3104		BossSession *arg1 = (BossSession *) 0 ;
3105	<	SwigValueWrapper< std::vector<BossJob * > > arg2 ;
3106	<	std::ostream &arg3_defvalue = std::cout ;
3107	<	std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
3108	<	jobStates const &arg4_defvalue = SCHEDULED ;
3109	<	jobStates *arg4 = (jobStates *) &arg4_defvalue ;
3110	<	printOption const &arg5_defvalue = NORMAL ;
3111	<	printOption *arg5 = (printOption *) &arg5_defvalue ;
3112	<	std::string const &arg6_defvalue = "" ;
3113	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
3114	<	std::vector<BossJob * > *argp2 ;
3115	<	std::string temp6 ;
3105	>	std::string const &arg2_defvalue = "all" ;
3106	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3107	>	std::string const &arg3_defvalue = "" ;
3108	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3109	>	std::string const &arg4_defvalue = "" ;
3110	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3111	>	std::string const &arg5_defvalue = "" ;
3112	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3113	>	std::vector<std::string > result;
3114	>	std::string temp2 ;
3115	>	std::string temp3 ;
3116	>	std::string temp4 ;
3117	>	std::string temp5 ;
3118		PyObject * obj0 = 0 ;
3119		PyObject * obj1 = 0 ;
3120		PyObject * obj2 = 0 ;
3121		PyObject * obj3 = 0 ;
3122		PyObject * obj4 = 0 ;
2641	–	PyObject * obj5 = 0 ;
3123
3124	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossSession_queryPrint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3124	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3125		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3126	<	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3127	<	arg2 = *argp2;
3126	>	if (obj1) {
3127	>	{
3128	>	if (PyString_Check(obj1)) {
3129	>	temp2 = std::string(PyString_AsString(obj1));
3130	>	arg2 = &temp2;
3131	>	}else {
3132	>	SWIG_exception(SWIG_TypeError, "string expected");
3133	>	}
3134	>	}
3135	>	}
3136		if (obj2) {
3137	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3138	<	if (arg3 == NULL) {
3139	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3137	>	{
3138	>	if (PyString_Check(obj2)) {
3139	>	temp3 = std::string(PyString_AsString(obj2));
3140	>	arg3 = &temp3;
3141	>	}else {
3142	>	SWIG_exception(SWIG_TypeError, "string expected");
3143	>	}
3144		}
3145		}
3146		if (obj3) {
3147	<	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3148	<	if (arg4 == NULL) {
3149	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3147	>	{
3148	>	if (PyString_Check(obj3)) {
3149	>	temp4 = std::string(PyString_AsString(obj3));
3150	>	arg4 = &temp4;
3151	>	}else {
3152	>	SWIG_exception(SWIG_TypeError, "string expected");
3153	>	}
3154		}
3155		}
3156		if (obj4) {
2660	–	if ((SWIG_ConvertPtr(obj4,(void **) &arg5, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2661	–	if (arg5 == NULL) {
2662	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2663	–	}
2664	–	}
2665	–	if (obj5) {
3157		{
3158	<	if (PyString_Check(obj5)) {
3159	<	temp6 = std::string(PyString_AsString(obj5));
3160	<	arg6 = &temp6;
3158	>	if (PyString_Check(obj4)) {
3159	>	temp5 = std::string(PyString_AsString(obj4));
3160	>	arg5 = &temp5;
3161		}else {
3162		SWIG_exception(SWIG_TypeError, "string expected");
3163		}
#	Line 2674 | Line 3165 | static PyObject *_wrap_BossSession_query
3165		}
3166		{
3167		try {
3168	<	(arg1)->queryPrint(arg2,*arg3,(jobStates const &)*arg4,(printOption const &)*arg5,(std::string const &)*arg6);
3168	>	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3169
3170	+	}catch (const BossSchedFailure & e) {
3171	+	PyErr_SetString ( SchedulerError, e.what() );
3172	+	return NULL;
3173		}catch (const std::exception& e) {
3174	<	SWIG_exception(SWIG_RuntimeError, e.what());
3174	>	PyErr_SetString ( BossError, e.what() );
3175	>	return NULL;
3176		}
3177		}
3178	<	Py_INCREF(Py_None); resultobj = Py_None;
3178	>	{
3179	>	resultobj = PyTuple_New((&result)->size());
3180	>	for (unsigned int i=0; i<(&result)->size(); i++)
3181	>	PyTuple_SetItem(resultobj,i,
3182	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3183	>	}
3184		return resultobj;
3185		fail:
3186		return NULL;
3187		}
3188
3189
3190	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3190	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3191		PyObject *resultobj;
3192		BossSession *arg1 = (BossSession *) 0 ;
3193	<	std::string const &arg2_defvalue = "all" ;
3194	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
2695	<	std::string const &arg3_defvalue = "" ;
3193	>	int arg2 = (int) SCHEDULED ;
3194	>	std::string const &arg3_defvalue = "all" ;
3195		std::string *arg3 = (std::string *) &arg3_defvalue ;
3196	<	std::string const &arg4_defvalue = "" ;
3196	>	std::string const &arg4_defvalue = "all" ;
3197		std::string *arg4 = (std::string *) &arg4_defvalue ;
3198		std::string const &arg5_defvalue = "" ;
3199		std::string *arg5 = (std::string *) &arg5_defvalue ;
3200	<	SwigValueWrapper< std::vector<std::string > > result;
3201	<	std::string temp2 ;
3200	>	std::string arg6 = (std::string) "" ;
3201	>	std::string arg7 = (std::string) "" ;
3202	>	std::string arg8 = (std::string) "" ;
3203	>	std::string arg9 = (std::string) "" ;
3204	>	unsigned int arg10 = (unsigned int) 0 ;
3205	>	bool arg11 = (bool) false ;
3206	>	SwigValueWrapper< std::vector<BossTask * > > result;
3207		std::string temp3 ;
3208		std::string temp4 ;
3209		std::string temp5 ;
3210		PyObject * obj0 = 0 ;
2707	–	PyObject * obj1 = 0 ;
3211		PyObject * obj2 = 0 ;
3212		PyObject * obj3 = 0 ;
3213		PyObject * obj4 = 0 ;
3214	+	PyObject * obj5 = 0 ;
3215	+	PyObject * obj6 = 0 ;
3216	+	PyObject * obj7 = 0 ;
3217	+	PyObject * obj8 = 0 ;
3218	+	PyObject * obj9 = 0 ;
3219	+	PyObject * obj10 = 0 ;
3220
3221	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3221	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3222		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2714	–	if (obj1) {
2715	–	{
2716	–	if (PyString_Check(obj1)) {
2717	–	temp2 = std::string(PyString_AsString(obj1));
2718	–	arg2 = &temp2;
2719	–	}else {
2720	–	SWIG_exception(SWIG_TypeError, "string expected");
2721	–	}
2722	–	}
2723	–	}
3223		if (obj2) {
3224		{
3225		if (PyString_Check(obj2)) {
#	Line 2751 | Line 3250 | static PyObject *_wrap_BossSession_selec
3250		}
3251		}
3252		}
3253	+	if (obj5) {
3254	+	{
3255	+	if (PyString_Check(obj5))
3256	+	arg6 = std::string(PyString_AsString(obj5));
3257	+	else
3258	+	SWIG_exception(SWIG_TypeError, "string expected");
3259	+	}
3260	+	}
3261	+	if (obj6) {
3262	+	{
3263	+	if (PyString_Check(obj6))
3264	+	arg7 = std::string(PyString_AsString(obj6));
3265	+	else
3266	+	SWIG_exception(SWIG_TypeError, "string expected");
3267	+	}
3268	+	}
3269	+	if (obj7) {
3270	+	{
3271	+	if (PyString_Check(obj7))
3272	+	arg8 = std::string(PyString_AsString(obj7));
3273	+	else
3274	+	SWIG_exception(SWIG_TypeError, "string expected");
3275	+	}
3276	+	}
3277	+	if (obj8) {
3278	+	{
3279	+	if (PyString_Check(obj8))
3280	+	arg9 = std::string(PyString_AsString(obj8));
3281	+	else
3282	+	SWIG_exception(SWIG_TypeError, "string expected");
3283	+	}
3284	+	}
3285	+	if (obj9) {
3286	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3287	+	if (PyErr_Occurred()) SWIG_fail;
3288	+	}
3289	+	if (obj10) {
3290	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3291	+	if (PyErr_Occurred()) SWIG_fail;
3292	+	}
3293		{
3294		try {
3295	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3295	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3296
3297	+	}catch (const BossSchedFailure & e) {
3298	+	PyErr_SetString ( SchedulerError, e.what() );
3299	+	return NULL;
3300		}catch (const std::exception& e) {
3301	<	SWIG_exception(SWIG_RuntimeError, e.what());
3301	>	PyErr_SetString ( BossError, e.what() );
3302	>	return NULL;
3303		}
3304		}
3305		{
3306	<	std::vector<std::string > * resultptr;
3307	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
3308	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
3306	>	std::vector<BossTask * > * resultptr;
3307	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3308	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3309		}
3310		return resultobj;
3311		fail:
#	Line 2770 | Line 3313 | static PyObject *_wrap_BossSession_selec
3313		}
3314
3315
3316	<	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
2774	<	PyObject *obj;
2775	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2776	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
2777	<	Py_INCREF(obj);
2778	<	return Py_BuildValue((char *)"");
2779	<	}
2780	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3316	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3317		PyObject *resultobj;
3318	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3319	<	char *arg2 ;
3318	>	BossSession *arg1 = (BossSession *) 0 ;
3319	>	std::vector<std::string > *arg2 = 0 ;
3320	>	PyObject *result;
3321		PyObject * obj0 = 0 ;
3322	+	PyObject * obj1 = 0 ;
3323
3324	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3325	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3324	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3325	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3326	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3327	>	if (arg2 == NULL) {
3328	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3329	>	}
3330		{
3331	<	if (arg2) {
3332	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3333	<	strcpy((char *) arg1->key,arg2);
3334	<	}else {
3335	<	arg1->key = 0;
3331	>	try {
3332	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3333	>
3334	>	}catch (const BossSchedFailure & e) {
3335	>	PyErr_SetString ( SchedulerError, e.what() );
3336	>	return NULL;
3337	>	}catch (const std::exception& e) {
3338	>	PyErr_SetString ( BossError, e.what() );
3339	>	return NULL;
3340		}
3341		}
3342	<	Py_INCREF(Py_None); resultobj = Py_None;
3342	>	resultobj = result;
3343		return resultobj;
3344		fail:
3345		return NULL;
3346		}
3347
3348
3349	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3349	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3350		PyObject *resultobj;
3351	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3352	<	char *result;
3351	>	BossSession *arg1 = (BossSession *) 0 ;
3352	>	PyObject *result;
3353		PyObject * obj0 = 0 ;
3354
3355	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3356	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3357	<	result = (char *) ((arg1)->key);
3358	<
3359	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3355	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3356	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3357	>	{
3358	>	try {
3359	>	result = (PyObject *)BossSession_CHTools(arg1);
3360	>
3361	>	}catch (const BossSchedFailure & e) {
3362	>	PyErr_SetString ( SchedulerError, e.what() );
3363	>	return NULL;
3364	>	}catch (const std::exception& e) {
3365	>	PyErr_SetString ( BossError, e.what() );
3366	>	return NULL;
3367	>	}
3368	>	}
3369	>	resultobj = result;
3370		return resultobj;
3371		fail:
3372		return NULL;
3373		}
3374
3375
3376	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3376	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3377		PyObject *resultobj;
3378	<	char *arg1 ;
3379	<	BossTaskException *result;
3378	>	BossSession *arg1 = (BossSession *) 0 ;
3379	>	PyObject *result;
3380	>	PyObject * obj0 = 0 ;
3381
3382	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3382	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3383	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3384		{
3385		try {
3386	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3386	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3387
3388	+	}catch (const BossSchedFailure & e) {
3389	+	PyErr_SetString ( SchedulerError, e.what() );
3390	+	return NULL;
3391		}catch (const std::exception& e) {
3392	<	SWIG_exception(SWIG_RuntimeError, e.what());
3392	>	PyErr_SetString ( BossError, e.what() );
3393	>	return NULL;
3394		}
3395		}
3396	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3396	>	resultobj = result;
3397		return resultobj;
3398		fail:
3399		return NULL;
3400		}
3401
3402
3403	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3403	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3404		PyObject *resultobj;
3405	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3406	<	char *result;
3405	>	BossSession *arg1 = (BossSession *) 0 ;
3406	>	PyObject *result;
3407		PyObject * obj0 = 0 ;
3408
3409	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3410	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3409	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3410	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3411		{
3412		try {
3413	<	result = (char *)((BossTaskException const *)arg1)->what();
3413	>	result = (PyObject *)BossSession_RTMons(arg1);
3414
3415	+	}catch (const BossSchedFailure & e) {
3416	+	PyErr_SetString ( SchedulerError, e.what() );
3417	+	return NULL;
3418		}catch (const std::exception& e) {
3419	<	SWIG_exception(SWIG_RuntimeError, e.what());
3419	>	PyErr_SetString ( BossError, e.what() );
3420	>	return NULL;
3421		}
3422		}
3423	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3423	>	resultobj = result;
3424		return resultobj;
3425		fail:
3426		return NULL;
3427		}
3428
3429
3430	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3430	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3431		PyObject *resultobj;
3432	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3432	>	BossSession *arg1 = (BossSession *) 0 ;
3433	>	PyObject *result;
3434		PyObject * obj0 = 0 ;
3435
3436	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3437	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3436	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3437	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3438		{
3439		try {
3440	<	delete arg1;
3440	>	result = (PyObject *)BossSession_schedulers(arg1);
3441
3442	+	}catch (const BossSchedFailure & e) {
3443	+	PyErr_SetString ( SchedulerError, e.what() );
3444	+	return NULL;
3445		}catch (const std::exception& e) {
3446	<	SWIG_exception(SWIG_RuntimeError, e.what());
3446	>	PyErr_SetString ( BossError, e.what() );
3447	>	return NULL;
3448		}
3449		}
3450	<	Py_INCREF(Py_None); resultobj = Py_None;
3450	>	resultobj = result;
3451		return resultobj;
3452		fail:
3453		return NULL;
3454		}
3455
3456
3457	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
2887	<	PyObject *obj;
2888	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2889	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
2890	<	Py_INCREF(obj);
2891	<	return Py_BuildValue((char *)"");
2892	<	}
2893	<	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3457	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3458		PyObject *resultobj;
3459	<	BossTask *arg1 = (BossTask *) 0 ;
3460	<	PyObject *arg2 = (PyObject *) 0 ;
3461	<	BossAttributeContainer *arg3 = 0 ;
3459	>	BossSession *arg1 = (BossSession *) 0 ;
3460	>	std::string *arg2 = 0 ;
3461	>	std::string *arg3 = 0 ;
3462	>	std::string const &arg4_defvalue = "" ;
3463	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3464	>	std::string const &arg5_defvalue = "" ;
3465	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3466	>	unsigned int arg6 = (unsigned int) 0 ;
3467	>	bool arg7 = (bool) false ;
3468		PyObject *result;
3469	+	std::string temp2 ;
3470	+	std::string temp3 ;
3471	+	std::string temp4 ;
3472	+	std::string temp5 ;
3473		PyObject * obj0 = 0 ;
3474		PyObject * obj1 = 0 ;
3475		PyObject * obj2 = 0 ;
3476	+	PyObject * obj3 = 0 ;
3477	+	PyObject * obj4 = 0 ;
3478	+	PyObject * obj5 = 0 ;
3479	+	PyObject * obj6 = 0 ;
3480
3481	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3482	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3483	<	arg2 = obj1;
3484	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3485	<	if (arg3 == NULL) {
3486	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3481	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3482	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3483	>	{
3484	>	if (PyString_Check(obj1)) {
3485	>	temp2 = std::string(PyString_AsString(obj1));
3486	>	arg2 = &temp2;
3487	>	}else {
3488	>	SWIG_exception(SWIG_TypeError, "string expected");
3489	>	}
3490	>	}
3491	>	{
3492	>	if (PyString_Check(obj2)) {
3493	>	temp3 = std::string(PyString_AsString(obj2));
3494	>	arg3 = &temp3;
3495	>	}else {
3496	>	SWIG_exception(SWIG_TypeError, "string expected");
3497	>	}
3498	>	}
3499	>	if (obj3) {
3500	>	{
3501	>	if (PyString_Check(obj3)) {
3502	>	temp4 = std::string(PyString_AsString(obj3));
3503	>	arg4 = &temp4;
3504	>	}else {
3505	>	SWIG_exception(SWIG_TypeError, "string expected");
3506	>	}
3507	>	}
3508	>	}
3509	>	if (obj4) {
3510	>	{
3511	>	if (PyString_Check(obj4)) {
3512	>	temp5 = std::string(PyString_AsString(obj4));
3513	>	arg5 = &temp5;
3514	>	}else {
3515	>	SWIG_exception(SWIG_TypeError, "string expected");
3516	>	}
3517	>	}
3518	>	}
3519	>	if (obj5) {
3520	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3521	>	if (PyErr_Occurred()) SWIG_fail;
3522	>	}
3523	>	if (obj6) {
3524	>	arg7 = PyInt_AsLong(obj6) ? true : false;
3525	>	if (PyErr_Occurred()) SWIG_fail;
3526		}
3527		{
3528		try {
3529	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3529	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3530
3531	+	}catch (const BossSchedFailure & e) {
3532	+	PyErr_SetString ( SchedulerError, e.what() );
3533	+	return NULL;
3534		}catch (const std::exception& e) {
3535	<	SWIG_exception(SWIG_RuntimeError, e.what());
3535	>	PyErr_SetString ( BossError, e.what() );
3536	>	return NULL;
3537		}
3538		}
3539		resultobj = result;
#	Line 2922 | Line 3543 | static PyObject *_wrap_BossTask_appendTo
3543		}
3544
3545
3546	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3546	>	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3547		PyObject *resultobj;
3548	<	BossTask *arg1 = (BossTask *) 0 ;
3549	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3548	>	BossSession *arg1 = (BossSession *) 0 ;
3549	>	int arg2 = (int) SCHEDULED ;
3550	>	std::string const &arg3_defvalue = "all" ;
3551	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3552	>	std::string const &arg4_defvalue = "all" ;
3553	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3554	>	std::string const &arg5_defvalue = "" ;
3555	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3556	>	std::string arg6 = (std::string) "" ;
3557	>	std::string arg7 = (std::string) "" ;
3558	>	std::string arg8 = (std::string) "" ;
3559	>	std::string arg9 = (std::string) "" ;
3560	>	unsigned int arg10 = (unsigned int) 0 ;
3561	>	bool arg11 = (bool) false ;
3562		PyObject *result;
3563	+	std::string temp3 ;
3564	+	std::string temp4 ;
3565	+	std::string temp5 ;
3566		PyObject * obj0 = 0 ;
3567	<	PyObject * obj1 = 0 ;
3567	>	PyObject * obj2 = 0 ;
3568	>	PyObject * obj3 = 0 ;
3569	>	PyObject * obj4 = 0 ;
3570	>	PyObject * obj5 = 0 ;
3571	>	PyObject * obj6 = 0 ;
3572	>	PyObject * obj7 = 0 ;
3573	>	PyObject * obj8 = 0 ;
3574	>	PyObject * obj9 = 0 ;
3575	>	PyObject * obj10 = 0 ;
3576
3577	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3578	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3579	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3580	<	if (arg2 == NULL) {
3581	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3577	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3578	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3579	>	if (obj2) {
3580	>	{
3581	>	if (PyString_Check(obj2)) {
3582	>	temp3 = std::string(PyString_AsString(obj2));
3583	>	arg3 = &temp3;
3584	>	}else {
3585	>	SWIG_exception(SWIG_TypeError, "string expected");
3586	>	}
3587	>	}
3588	>	}
3589	>	if (obj3) {
3590	>	{
3591	>	if (PyString_Check(obj3)) {
3592	>	temp4 = std::string(PyString_AsString(obj3));
3593	>	arg4 = &temp4;
3594	>	}else {
3595	>	SWIG_exception(SWIG_TypeError, "string expected");
3596	>	}
3597	>	}
3598	>	}
3599	>	if (obj4) {
3600	>	{
3601	>	if (PyString_Check(obj4)) {
3602	>	temp5 = std::string(PyString_AsString(obj4));
3603	>	arg5 = &temp5;
3604	>	}else {
3605	>	SWIG_exception(SWIG_TypeError, "string expected");
3606	>	}
3607	>	}
3608	>	}
3609	>	if (obj5) {
3610	>	{
3611	>	if (PyString_Check(obj5))
3612	>	arg6 = std::string(PyString_AsString(obj5));
3613	>	else
3614	>	SWIG_exception(SWIG_TypeError, "string expected");
3615	>	}
3616	>	}
3617	>	if (obj6) {
3618	>	{
3619	>	if (PyString_Check(obj6))
3620	>	arg7 = std::string(PyString_AsString(obj6));
3621	>	else
3622	>	SWIG_exception(SWIG_TypeError, "string expected");
3623	>	}
3624	>	}
3625	>	if (obj7) {
3626	>	{
3627	>	if (PyString_Check(obj7))
3628	>	arg8 = std::string(PyString_AsString(obj7));
3629	>	else
3630	>	SWIG_exception(SWIG_TypeError, "string expected");
3631	>	}
3632	>	}
3633	>	if (obj8) {
3634	>	{
3635	>	if (PyString_Check(obj8))
3636	>	arg9 = std::string(PyString_AsString(obj8));
3637	>	else
3638	>	SWIG_exception(SWIG_TypeError, "string expected");
3639	>	}
3640	>	}
3641	>	if (obj9) {
3642	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3643	>	if (PyErr_Occurred()) SWIG_fail;
3644	>	}
3645	>	if (obj10) {
3646	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3647	>	if (PyErr_Occurred()) SWIG_fail;
3648		}
3649		{
3650		try {
3651	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3651	>	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3652
3653	+	}catch (const BossSchedFailure & e) {
3654	+	PyErr_SetString ( SchedulerError, e.what() );
3655	+	return NULL;
3656		}catch (const std::exception& e) {
3657	<	SWIG_exception(SWIG_RuntimeError, e.what());
3657	>	PyErr_SetString ( BossError, e.what() );
3658	>	return NULL;
3659		}
3660		}
3661		resultobj = result;
#	Line 2951 | Line 3665 | static PyObject *_wrap_BossTask_jobDict(
3665		}
3666
3667
3668	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3668	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3669	>	PyObject *obj;
3670	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3671	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3672	>	Py_INCREF(obj);
3673	>	return Py_BuildValue((char *)"");
3674	>	}
3675	>	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3676		PyObject *resultobj;
3677	<	BossTask *arg1 = (BossTask *) 0 ;
3678	<	PyObject *result;
3677	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3678	>	char *arg2 ;
3679		PyObject * obj0 = 0 ;
3680
3681	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3682	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3681	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3682	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3683		{
3684	<	try {
3685	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3686	<
3687	<	}catch (const std::exception& e) {
3688	<	SWIG_exception(SWIG_RuntimeError, e.what());
3684	>	if (arg2) {
3685	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3686	>	strcpy((char *) arg1->key,arg2);
3687	>	}else {
3688	>	arg1->key = 0;
3689		}
3690		}
3691	<	resultobj = result;
3691	>	Py_INCREF(Py_None); resultobj = Py_None;
3692		return resultobj;
3693		fail:
3694		return NULL;
3695		}
3696
3697
3698	<	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3699	<	int argc;
3700	<	PyObject *argv[2];
3701	<	int ii;
3698	>	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3699	>	PyObject *resultobj;
3700	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3701	>	char *result;
3702	>	PyObject * obj0 = 0 ;
3703
3704	<	argc = PyObject_Length(args);
3705	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
3706	<	argv[ii] = PyTuple_GetItem(args,ii);
2985	<	}
2986	<	if (argc == 1) {
2987	<	int _v;
2988	<	{
2989	<	void *ptr;
2990	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
2991	<	_v = 0;
2992	<	PyErr_Clear();
2993	<	}else {
2994	<	_v = 1;
2995	<	}
2996	<	}
2997	<	if (_v) {
2998	<	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
2999	<	}
3000	<	}
3704	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3705	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3706	>	result = (char *) ((arg1)->key);
3707
3708	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
3708	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3709	>	return resultobj;
3710	>	fail:
3711		return NULL;
3712		}
3713
3714
3715	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3715	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3716		PyObject *resultobj;
3717	<	BossTask *arg1 = (BossTask *) 0 ;
3718	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3011	<	PyObject *result;
3012	<	PyObject * obj0 = 0 ;
3013	<	PyObject * obj1 = 0 ;
3717	>	char *arg1 ;
3718	>	BossTaskException *result;
3719
3720	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3016	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3017	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3018	<	if (arg2 == NULL) {
3019	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3020	<	}
3720	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3721		{
3722		try {
3723	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3723	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3724
3725	+	}catch (const BossSchedFailure & e) {
3726	+	PyErr_SetString ( SchedulerError, e.what() );
3727	+	return NULL;
3728		}catch (const std::exception& e) {
3729	<	SWIG_exception(SWIG_RuntimeError, e.what());
3729	>	PyErr_SetString ( BossError, e.what() );
3730	>	return NULL;
3731		}
3732		}
3733	<	resultobj = result;
3733	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3734		return resultobj;
3735		fail:
3736		return NULL;
3737		}
3738
3739
3740	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
3740	>	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3741		PyObject *resultobj;
3742	<	BossTask *arg1 = (BossTask *) 0 ;
3743	<	std::string *arg2 = 0 ;
3040	<	PyObject *result;
3041	<	std::string temp2 ;
3742	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3743	>	char *result;
3744		PyObject * obj0 = 0 ;
3043	–	PyObject * obj1 = 0 ;
3745
3746	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
3747	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3746	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3747	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3748		{
3749	<	if (PyString_Check(obj1)) {
3750	<	temp2 = std::string(PyString_AsString(obj1));
3751	<	arg2 = &temp2;
3752	<	}else {
3753	<	SWIG_exception(SWIG_TypeError, "string expected");
3749	>	try {
3750	>	result = (char *)((BossTaskException const *)arg1)->what();
3751	>
3752	>	}catch (const BossSchedFailure & e) {
3753	>	PyErr_SetString ( SchedulerError, e.what() );
3754	>	return NULL;
3755	>	}catch (const std::exception& e) {
3756	>	PyErr_SetString ( BossError, e.what() );
3757	>	return NULL;
3758		}
3759		}
3760	+	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3761	+	return resultobj;
3762	+	fail:
3763	+	return NULL;
3764	+	}
3765	+
3766	+
3767	+	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3768	+	PyObject *resultobj;
3769	+	BossTaskException *arg1 = (BossTaskException *) 0 ;
3770	+	PyObject * obj0 = 0 ;
3771	+
3772	+	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3773	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3774		{
3775		try {
3776	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
3776	>	delete arg1;
3777
3778	+	}catch (const BossSchedFailure & e) {
3779	+	PyErr_SetString ( SchedulerError, e.what() );
3780	+	return NULL;
3781		}catch (const std::exception& e) {
3782	<	SWIG_exception(SWIG_RuntimeError, e.what());
3782	>	PyErr_SetString ( BossError, e.what() );
3783	>	return NULL;
3784		}
3785		}
3786	<	resultobj = result;
3786	>	Py_INCREF(Py_None); resultobj = Py_None;
3787		return resultobj;
3788		fail:
3789		return NULL;
3790		}
3791
3792
3793	+	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3794	+	PyObject *obj;
3795	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3796	+	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3797	+	Py_INCREF(obj);
3798	+	return Py_BuildValue((char *)"");
3799	+	}
3800		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
3801		PyObject *resultobj;
3802		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 3079 | Line 3809 | static PyObject *_wrap_new_BossTask__SWI
3809		try {
3810		result = (BossTask *)new BossTask(arg1);
3811
3812	+	}catch (const BossSchedFailure & e) {
3813	+	PyErr_SetString ( SchedulerError, e.what() );
3814	+	return NULL;
3815		}catch (const std::exception& e) {
3816	<	SWIG_exception(SWIG_RuntimeError, e.what());
3816	>	PyErr_SetString ( BossError, e.what() );
3817	>	return NULL;
3818		}
3819		}
3820		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3113 | Line 3847 | static PyObject *_wrap_new_BossTask__SWI
3847		try {
3848		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3849
3850	+	}catch (const BossSchedFailure & e) {
3851	+	PyErr_SetString ( SchedulerError, e.what() );
3852	+	return NULL;
3853		}catch (const std::exception& e) {
3854	<	SWIG_exception(SWIG_RuntimeError, e.what());
3854	>	PyErr_SetString ( BossError, e.what() );
3855	>	return NULL;
3856		}
3857		}
3858		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3135 | Line 3873 | static PyObject *_wrap_delete_BossTask(P
3873		try {
3874		delete arg1;
3875
3876	+	}catch (const BossSchedFailure & e) {
3877	+	PyErr_SetString ( SchedulerError, e.what() );
3878	+	return NULL;
3879		}catch (const std::exception& e) {
3880	<	SWIG_exception(SWIG_RuntimeError, e.what());
3880	>	PyErr_SetString ( BossError, e.what() );
3881	>	return NULL;
3882		}
3883		}
3884		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3161 | Line 3903 | static PyObject *_wrap_new_BossTask__SWI
3903		try {
3904		result = (BossTask *)new BossTask((BossTask const &)*arg1);
3905
3906	+	}catch (const BossSchedFailure & e) {
3907	+	PyErr_SetString ( SchedulerError, e.what() );
3908	+	return NULL;
3909		}catch (const std::exception& e) {
3910	<	SWIG_exception(SWIG_RuntimeError, e.what());
3910	>	PyErr_SetString ( BossError, e.what() );
3911	>	return NULL;
3912		}
3913		}
3914		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3252 | Line 3998 | static PyObject *_wrap_BossTask_id(PyObj
3998		result = (std::string *) &_result_ref;
3999		}
4000
4001	+	}catch (const BossSchedFailure & e) {
4002	+	PyErr_SetString ( SchedulerError, e.what() );
4003	+	return NULL;
4004		}catch (const std::exception& e) {
4005	<	SWIG_exception(SWIG_RuntimeError, e.what());
4005	>	PyErr_SetString ( BossError, e.what() );
4006	>	return NULL;
4007		}
4008		}
4009		{
#	Line 3280 | Line 4030 | static PyObject *_wrap_BossTask_name(PyO
4030		result = (std::string *) &_result_ref;
4031		}
4032
4033	+	}catch (const BossSchedFailure & e) {
4034	+	PyErr_SetString ( SchedulerError, e.what() );
4035	+	return NULL;
4036		}catch (const std::exception& e) {
4037	<	SWIG_exception(SWIG_RuntimeError, e.what());
4037	>	PyErr_SetString ( BossError, e.what() );
4038	>	return NULL;
4039		}
4040		}
4041		{
#	Line 3293 | Line 4047 | static PyObject *_wrap_BossTask_name(PyO
4047		}
4048
4049
4050	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
4050	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4051		PyObject *resultobj;
4052		BossTask *arg1 = (BossTask *) 0 ;
4053	<	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4053	>	std::map<std::string,std::string > result;
4054		PyObject * obj0 = 0 ;
4055
4056	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4056	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4057		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4058		{
4059		try {
4060	<	result = ((BossTask const *)arg1)->jobsMap();
4060	>	result = ((BossTask const *)arg1)->taskMap();
4061
4062	+	}catch (const BossSchedFailure & e) {
4063	+	PyErr_SetString ( SchedulerError, e.what() );
4064	+	return NULL;
4065		}catch (const std::exception& e) {
4066	<	SWIG_exception(SWIG_RuntimeError, e.what());
4066	>	PyErr_SetString ( BossError, e.what() );
4067	>	return NULL;
4068		}
4069		}
4070		{
4071	<	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4072	<	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4073	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4071	>	resultobj = PyDict_New();
4072	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4073	>	PyDict_SetItem(resultobj,
4074	>	SwigString_FromString(i->first),
4075	>	SwigString_FromString(i->second));
4076	>	}
4077		}
4078		return resultobj;
4079		fail:
#	Line 3320 | Line 4081 | static PyObject *_wrap_BossTask_jobsMap_
4081		}
4082
4083
4084	<	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4084	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
4085		PyObject *resultobj;
4086		BossTask *arg1 = (BossTask *) 0 ;
4087	<	unsigned int arg2 ;
3327	<	std::map<std::string,std::string > result;
4087	>	BossTask::job_iterator result;
4088		PyObject * obj0 = 0 ;
3329	–	PyObject * obj1 = 0 ;
4089
4090	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4090	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
4091		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3333	–	arg2 = (unsigned int) PyInt_AsLong(obj1);
3334	–	if (PyErr_Occurred()) SWIG_fail;
4092		{
4093		try {
4094	<	result = ((BossTask const *)arg1)->jobMap(arg2);
4094	>	result = ((BossTask const *)arg1)->job_begin();
4095
4096	+	}catch (const BossSchedFailure & e) {
4097	+	PyErr_SetString ( SchedulerError, e.what() );
4098	+	return NULL;
4099		}catch (const std::exception& e) {
4100	<	SWIG_exception(SWIG_RuntimeError, e.what());
4100	>	PyErr_SetString ( BossError, e.what() );
4101	>	return NULL;
4102		}
4103		}
4104		{
4105	<	resultobj = PyDict_New();
4106	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4107	<	PyDict_SetItem(resultobj,
4108	<	SwigString_FromString(i->first),
4109	<	SwigString_FromString(i->second));
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_job_end(PyObject *self, PyObject *args) {
4116	>	PyObject *resultobj;
4117	>	BossTask *arg1 = (BossTask *) 0 ;
4118	>	BossTask::job_iterator result;
4119	>	PyObject * obj0 = 0 ;
4120	>
4121	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&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)->job_end();
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	+	BossTask::job_iterator * resultptr;
4137	+	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4138	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4139	+	}
4140		return resultobj;
4141		fail:
4142		return NULL;
4143		}
4144
4145
4146	<	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4146	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4147	>	PyObject *resultobj;
4148	>	BossTask *arg1 = (BossTask *) 0 ;
4149	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4150	>	PyObject * obj0 = 0 ;
4151	>
4152	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4153	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4154	>	{
4155	>	try {
4156	>	result = ((BossTask const *)arg1)->jobsMap();
4157	>
4158	>	}catch (const BossSchedFailure & e) {
4159	>	PyErr_SetString ( SchedulerError, e.what() );
4160	>	return NULL;
4161	>	}catch (const std::exception& e) {
4162	>	PyErr_SetString ( BossError, e.what() );
4163	>	return NULL;
4164	>	}
4165	>	}
4166	>	{
4167	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4168	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4169	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4170	>	}
4171	>	return resultobj;
4172	>	fail:
4173	>	return NULL;
4174	>	}
4175	>
4176	>
4177	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4178		PyObject *resultobj;
4179		BossTask *arg1 = (BossTask *) 0 ;
4180		SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
#	Line 3377 | Line 4197 | static PyObject *_wrap_BossTask_jobMap__
4197		try {
4198		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4199
4200	+	}catch (const BossSchedFailure & e) {
4201	+	PyErr_SetString ( SchedulerError, e.what() );
4202	+	return NULL;
4203		}catch (const std::exception& e) {
4204	<	SWIG_exception(SWIG_RuntimeError, e.what());
4204	>	PyErr_SetString ( BossError, e.what() );
4205	>	return NULL;
4206		}
4207		}
4208		{
#	Line 3390 | Line 4214 | static PyObject *_wrap_BossTask_jobMap__
4214		}
4215
4216
4217	+	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4218	+	PyObject *resultobj;
4219	+	BossTask *arg1 = (BossTask *) 0 ;
4220	+	unsigned int arg2 ;
4221	+	std::map<std::string,std::string > result;
4222	+	PyObject * obj0 = 0 ;
4223	+	PyObject * obj1 = 0 ;
4224	+
4225	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4226	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4227	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
4228	+	if (PyErr_Occurred()) SWIG_fail;
4229	+	{
4230	+	try {
4231	+	result = ((BossTask const *)arg1)->jobMap(arg2);
4232	+
4233	+	}catch (const BossSchedFailure & e) {
4234	+	PyErr_SetString ( SchedulerError, e.what() );
4235	+	return NULL;
4236	+	}catch (const std::exception& e) {
4237	+	PyErr_SetString ( BossError, e.what() );
4238	+	return NULL;
4239	+	}
4240	+	}
4241	+	{
4242	+	resultobj = PyDict_New();
4243	+	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4244	+	PyDict_SetItem(resultobj,
4245	+	SwigString_FromString(i->first),
4246	+	SwigString_FromString(i->second));
4247	+	}
4248	+	}
4249	+	return resultobj;
4250	+	fail:
4251	+	return NULL;
4252	+	}
4253	+
4254	+
4255		static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
4256		int argc;
4257		PyObject *argv[4];
#	Line 3415 | Line 4277 | static PyObject *_wrap_BossTask_jobMap(P
4277		_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
4278		}
4279		if (_v) {
4280	<	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4280	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4281		}
4282		}
4283		}
#	Line 3451 | Line 4313 | static PyObject *_wrap_BossTask_jobMap(P
4313		}
4314		}
4315		if (_v) {
4316	<	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4316	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4317		}
4318		}
4319		}
#	Line 3462 | Line 4324 | static PyObject *_wrap_BossTask_jobMap(P
4324		}
4325
4326
4327	<	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3466	<	PyObject *resultobj;
3467	<	BossTask *arg1 = (BossTask *) 0 ;
3468	<	BossTask::job_iterator result;
3469	<	PyObject * obj0 = 0 ;
3470	<
3471	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3472	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3473	<	{
3474	<	try {
3475	<	result = ((BossTask const *)arg1)->job_begin();
3476	<
3477	<	}catch (const std::exception& e) {
3478	<	SWIG_exception(SWIG_RuntimeError, e.what());
3479	<	}
3480	<	}
3481	<	{
3482	<	BossTask::job_iterator * resultptr;
3483	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3484	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3485	<	}
3486	<	return resultobj;
3487	<	fail:
3488	<	return NULL;
3489	<	}
3490	<
3491	<
3492	<	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4327	>	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4328		PyObject *resultobj;
4329		BossTask *arg1 = (BossTask *) 0 ;
4330	<	BossTask::job_iterator result;
4330	>	BossJob *arg2 = (BossJob *) 0 ;
4331	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4332		PyObject * obj0 = 0 ;
4333	+	PyObject * obj1 = 0 ;
4334
4335	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4335	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
4336		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4337	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4338		{
4339		try {
4340	<	result = ((BossTask const *)arg1)->job_end();
4340	>	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4341
4342	+	}catch (const BossSchedFailure & e) {
4343	+	PyErr_SetString ( SchedulerError, e.what() );
4344	+	return NULL;
4345		}catch (const std::exception& e) {
4346	<	SWIG_exception(SWIG_RuntimeError, e.what());
4346	>	PyErr_SetString ( BossError, e.what() );
4347	>	return NULL;
4348		}
4349		}
4350		{
4351	<	BossTask::job_iterator * resultptr;
4352	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4353	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4351	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4352	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4353	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4354		}
4355		return resultobj;
4356		fail:
#	Line 3531 | Line 4373 | static PyObject *_wrap_BossTask_queryJob
4373		try {
4374		result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4375
4376	+	}catch (const BossSchedFailure & e) {
4377	+	PyErr_SetString ( SchedulerError, e.what() );
4378	+	return NULL;
4379		}catch (const std::exception& e) {
4380	<	SWIG_exception(SWIG_RuntimeError, e.what());
4380	>	PyErr_SetString ( BossError, e.what() );
4381	>	return NULL;
4382		}
4383		}
4384		{
#	Line 3546 | Line 4392 | static PyObject *_wrap_BossTask_queryJob
4392		}
4393
4394
3549	–	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
3550	–	PyObject *resultobj;
3551	–	BossTask *arg1 = (BossTask *) 0 ;
3552	–	BossJob *arg2 = (BossJob *) 0 ;
3553	–	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3554	–	PyObject * obj0 = 0 ;
3555	–	PyObject * obj1 = 0 ;
3556	–
3557	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
3558	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3559	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3560	–	{
3561	–	try {
3562	–	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
3563	–
3564	–	}catch (const std::exception& e) {
3565	–	SWIG_exception(SWIG_RuntimeError, e.what());
3566	–	}
3567	–	}
3568	–	{
3569	–	std::map<std::string,std::map<std::string,std::string > > * resultptr;
3570	–	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3571	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3572	–	}
3573	–	return resultobj;
3574	–	fail:
3575	–	return NULL;
3576	–	}
3577	–
3578	–
4395		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4396		PyObject *resultobj;
4397		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3612 | Line 4428 | static PyObject *_wrap_BossTask_declare_
4428		try {
4429		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4430
4431	+	}catch (const BossSchedFailure & e) {
4432	+	PyErr_SetString ( SchedulerError, e.what() );
4433	+	return NULL;
4434		}catch (const std::exception& e) {
4435	<	SWIG_exception(SWIG_RuntimeError, e.what());
4435	>	PyErr_SetString ( BossError, e.what() );
4436	>	return NULL;
4437		}
4438		}
4439		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3651 | Line 4471 | static PyObject *_wrap_BossTask_declare_
4471		try {
4472		(arg1)->declare(arg2,(std::string const &)*arg3);
4473
4474	+	}catch (const BossSchedFailure & e) {
4475	+	PyErr_SetString ( SchedulerError, e.what() );
4476	+	return NULL;
4477		}catch (const std::exception& e) {
4478	<	SWIG_exception(SWIG_RuntimeError, e.what());
4478	>	PyErr_SetString ( BossError, e.what() );
4479	>	return NULL;
4480		}
4481		}
4482		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3750 | Line 4574 | static PyObject *_wrap_BossTask_remove(P
4574		try {
4575		(arg1)->remove();
4576
4577	+	}catch (const BossSchedFailure & e) {
4578	+	PyErr_SetString ( SchedulerError, e.what() );
4579	+	return NULL;
4580		}catch (const std::exception& e) {
4581	<	SWIG_exception(SWIG_RuntimeError, e.what());
4581	>	PyErr_SetString ( BossError, e.what() );
4582	>	return NULL;
4583		}
4584		}
4585		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3786 | Line 4614 | static PyObject *_wrap_BossTask_archive(
4614		try {
4615		(arg1)->archive((std::string const &)*arg2);
4616
4617	+	}catch (const BossSchedFailure & e) {
4618	+	PyErr_SetString ( SchedulerError, e.what() );
4619	+	return NULL;
4620		}catch (const std::exception& e) {
4621	<	SWIG_exception(SWIG_RuntimeError, e.what());
4621	>	PyErr_SetString ( BossError, e.what() );
4622	>	return NULL;
4623		}
4624		}
4625		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3797 | Line 4629 | static PyObject *_wrap_BossTask_archive(
4629		}
4630
4631
3800	–	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3801	–	PyObject *resultobj;
3802	–	BossTask *arg1 = (BossTask *) 0 ;
3803	–	std::map<std::string,std::string > result;
3804	–	PyObject * obj0 = 0 ;
3805	–
3806	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3807	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3808	–	{
3809	–	try {
3810	–	result = ((BossTask const *)arg1)->taskMap();
3811	–
3812	–	}catch (const std::exception& e) {
3813	–	SWIG_exception(SWIG_RuntimeError, e.what());
3814	–	}
3815	–	}
3816	–	{
3817	–	resultobj = PyDict_New();
3818	–	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3819	–	PyDict_SetItem(resultobj,
3820	–	SwigString_FromString(i->first),
3821	–	SwigString_FromString(i->second));
3822	–	}
3823	–	}
3824	–	return resultobj;
3825	–	fail:
3826	–	return NULL;
3827	–	}
3828	–
3829	–
4632		static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4633		PyObject *resultobj;
4634		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3840 | Line 4642 | static PyObject *_wrap_BossTask_submit(P
4642		std::string *arg5 = (std::string *) &arg5_defvalue ;
4643		std::string const &arg6_defvalue = "" ;
4644		std::string *arg6 = (std::string *) &arg6_defvalue ;
4645	<	bool arg7 = (bool) false ;
4645	>	unsigned int arg7 = (unsigned int) 0 ;
4646	>	bool arg8 = (bool) false ;
4647		int result;
4648		std::string temp2 ;
4649		std::string temp3 ;
#	Line 3854 | Line 4657 | static PyObject *_wrap_BossTask_submit(P
4657		PyObject * obj4 = 0 ;
4658		PyObject * obj5 = 0 ;
4659		PyObject * obj6 = 0 ;
4660	+	PyObject * obj7 = 0 ;
4661
4662	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4662	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4663		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4664		if (obj1) {
4665		{
#	Line 3908 | Line 4712 | static PyObject *_wrap_BossTask_submit(P
4712		}
4713		}
4714		if (obj6) {
4715	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4715	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4716	>	if (PyErr_Occurred()) SWIG_fail;
4717	>	}
4718	>	if (obj7) {
4719	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4720		if (PyErr_Occurred()) SWIG_fail;
4721		}
4722		{
4723		try {
4724	<	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);
4724	>	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7,arg8);
4725
4726	+	}catch (const BossSchedFailure & e) {
4727	+	PyErr_SetString ( SchedulerError, e.what() );
4728	+	return NULL;
4729		}catch (const std::exception& e) {
4730	<	SWIG_exception(SWIG_RuntimeError, e.what());
4730	>	PyErr_SetString ( BossError, e.what() );
4731	>	return NULL;
4732		}
4733		}
4734		resultobj = PyInt_FromLong((long)result);
#	Line 3955 | Line 4767 | static PyObject *_wrap_BossTask_reSubmit
4767		try {
4768		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4769
4770	+	}catch (const BossSchedFailure & e) {
4771	+	PyErr_SetString ( SchedulerError, e.what() );
4772	+	return NULL;
4773		}catch (const std::exception& e) {
4774	<	SWIG_exception(SWIG_RuntimeError, e.what());
4774	>	PyErr_SetString ( BossError, e.what() );
4775	>	return NULL;
4776		}
4777		}
4778		resultobj = PyInt_FromLong((long)result);
#	Line 3970 | Line 4786 | static PyObject *_wrap_BossTask_kill(PyO
4786		PyObject *resultobj;
4787		BossTask *arg1 = (BossTask *) 0 ;
4788		std::string *arg2 = 0 ;
4789	<	bool arg3 = (bool) false ;
4789	>	unsigned int arg3 = (unsigned int) 0 ;
4790	>	bool arg4 = (bool) false ;
4791		int result;
4792		std::string temp2 ;
4793		PyObject * obj0 = 0 ;
4794		PyObject * obj1 = 0 ;
4795		PyObject * obj2 = 0 ;
4796	+	PyObject * obj3 = 0 ;
4797
4798	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
4798	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
4799		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4800		{
4801		if (PyString_Check(obj1)) {
#	Line 3988 | Line 4806 | static PyObject *_wrap_BossTask_kill(PyO
4806		}
4807		}
4808		if (obj2) {
4809	<	arg3 = PyInt_AsLong(obj2) ? true : false;
4809	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
4810	>	if (PyErr_Occurred()) SWIG_fail;
4811	>	}
4812	>	if (obj3) {
4813	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4814		if (PyErr_Occurred()) SWIG_fail;
4815		}
4816		{
4817		try {
4818	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4818	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
4819
4820	+	}catch (const BossSchedFailure & e) {
4821	+	PyErr_SetString ( SchedulerError, e.what() );
4822	+	return NULL;
4823		}catch (const std::exception& e) {
4824	<	SWIG_exception(SWIG_RuntimeError, e.what());
4824	>	PyErr_SetString ( BossError, e.what() );
4825	>	return NULL;
4826		}
4827		}
4828		resultobj = PyInt_FromLong((long)result);
#	Line 4006 | Line 4832 | static PyObject *_wrap_BossTask_kill(PyO
4832		}
4833
4834
4835	<	static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
4835	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4836		PyObject *resultobj;
4837		BossTask *arg1 = (BossTask *) 0 ;
4838		std::string const &arg2_defvalue = "all" ;
4839		std::string *arg2 = (std::string *) &arg2_defvalue ;
4840		std::string const &arg3_defvalue = "" ;
4841		std::string *arg3 = (std::string *) &arg3_defvalue ;
4842	<	bool arg4 = (bool) false ;
4842	>	unsigned int arg4 = (unsigned int) 0 ;
4843		bool arg5 = (bool) false ;
4844	+	bool arg6 = (bool) false ;
4845		int result;
4846		std::string temp2 ;
4847		std::string temp3 ;
#	Line 4023 | Line 4850 | static PyObject *_wrap_BossTask_getOutpu
4850		PyObject * obj2 = 0 ;
4851		PyObject * obj3 = 0 ;
4852		PyObject * obj4 = 0 ;
4853	+	PyObject * obj5 = 0 ;
4854
4855	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4855	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
4856		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4857		if (obj1) {
4858		{
#	Line 4047 | Line 4875 | static PyObject *_wrap_BossTask_getOutpu
4875		}
4876		}
4877		if (obj3) {
4878	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4878	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
4879		if (PyErr_Occurred()) SWIG_fail;
4880		}
4881		if (obj4) {
4882		arg5 = PyInt_AsLong(obj4) ? true : false;
4883		if (PyErr_Occurred()) SWIG_fail;
4884		}
4885	+	if (obj5) {
4886	+	arg6 = PyInt_AsLong(obj5) ? true : false;
4887	+	if (PyErr_Occurred()) SWIG_fail;
4888	+	}
4889		{
4890		try {
4891	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4891	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
4892
4893	+	}catch (const BossSchedFailure & e) {
4894	+	PyErr_SetString ( SchedulerError, e.what() );
4895	+	return NULL;
4896		}catch (const std::exception& e) {
4897	<	SWIG_exception(SWIG_RuntimeError, e.what());
4897	>	PyErr_SetString ( BossError, e.what() );
4898	>	return NULL;
4899		}
4900		}
4901		resultobj = PyInt_FromLong((long)result);
#	Line 4069 | Line 4905 | static PyObject *_wrap_BossTask_getOutpu
4905		}
4906
4907
4908	<	static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
4908	>	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
4909		PyObject *resultobj;
4910		BossTask *arg1 = (BossTask *) 0 ;
4911	<	std::string const &arg2_defvalue = "" ;
4912	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
4913	<	bool arg3 = (bool) false ;
4914	<	bool arg4 = (bool) false ;
4911	>	int arg2 = (int) SCHEDULED ;
4912	>	std::string const &arg3_defvalue = "all" ;
4913	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4914	>	std::string const &arg4_defvalue = "" ;
4915	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4916	>	std::string arg5 = (std::string) "" ;
4917	>	std::string arg6 = (std::string) "" ;
4918	>	std::string arg7 = (std::string) "" ;
4919	>	std::string arg8 = (std::string) "" ;
4920		int result;
4921	<	std::string temp2 ;
4921	>	std::string temp3 ;
4922	>	std::string temp4 ;
4923		PyObject * obj0 = 0 ;
4082	–	PyObject * obj1 = 0 ;
4924		PyObject * obj2 = 0 ;
4925		PyObject * obj3 = 0 ;
4926	+	PyObject * obj4 = 0 ;
4927	+	PyObject * obj5 = 0 ;
4928	+	PyObject * obj6 = 0 ;
4929	+	PyObject * obj7 = 0 ;
4930
4931	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4931	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4932		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4933	<	if (obj1) {
4933	>	if (obj2) {
4934		{
4935	<	if (PyString_Check(obj1)) {
4936	<	temp2 = std::string(PyString_AsString(obj1));
4937	<	arg2 = &temp2;
4935	>	if (PyString_Check(obj2)) {
4936	>	temp3 = std::string(PyString_AsString(obj2));
4937	>	arg3 = &temp3;
4938		}else {
4939		SWIG_exception(SWIG_TypeError, "string expected");
4940		}
4941		}
4942		}
4098	–	if (obj2) {
4099	–	arg3 = PyInt_AsLong(obj2) ? true : false;
4100	–	if (PyErr_Occurred()) SWIG_fail;
4101	–	}
4943		if (obj3) {
4944	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4945	<	if (PyErr_Occurred()) SWIG_fail;
4946	<	}
4947	<	{
4948	<	try {
4949	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
4950	<
4110	<	}catch (const std::exception& e) {
4111	<	SWIG_exception(SWIG_RuntimeError, e.what());
4944	>	{
4945	>	if (PyString_Check(obj3)) {
4946	>	temp4 = std::string(PyString_AsString(obj3));
4947	>	arg4 = &temp4;
4948	>	}else {
4949	>	SWIG_exception(SWIG_TypeError, "string expected");
4950	>	}
4951		}
4952		}
4953	<	resultobj = PyInt_FromLong((long)result);
4954	<	return resultobj;
4955	<	fail:
4956	<	return NULL;
4957	<	}
4958	<
4959	<
4121	<	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4122	<	int argc;
4123	<	PyObject *argv[6];
4124	<	int ii;
4125	<
4126	<	argc = PyObject_Length(args);
4127	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
4128	<	argv[ii] = PyTuple_GetItem(args,ii);
4953	>	if (obj4) {
4954	>	{
4955	>	if (PyString_Check(obj4))
4956	>	arg5 = std::string(PyString_AsString(obj4));
4957	>	else
4958	>	SWIG_exception(SWIG_TypeError, "string expected");
4959	>	}
4960		}
4961	<	if ((argc >= 1) && (argc <= 5)) {
4131	<	int _v;
4961	>	if (obj5) {
4962		{
4963	<	void *ptr;
4964	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4965	<	_v = 0;
4966	<	PyErr_Clear();
4137	<	}else {
4138	<	_v = 1;
4139	<	}
4963	>	if (PyString_Check(obj5))
4964	>	arg6 = std::string(PyString_AsString(obj5));
4965	>	else
4966	>	SWIG_exception(SWIG_TypeError, "string expected");
4967		}
4968	<	if (_v) {
4969	<	if (argc <= 1) {
4970	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4971	<	}
4972	<	{
4973	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4974	<	}
4148	<	if (_v) {
4149	<	if (argc <= 2) {
4150	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4151	<	}
4152	<	{
4153	<	_v = PyString_Check(argv[2]) ? 1 : 0;
4154	<	}
4155	<	if (_v) {
4156	<	if (argc <= 3) {
4157	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4158	<	}
4159	<	{
4160	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4161	<	}
4162	<	if (_v) {
4163	<	if (argc <= 4) {
4164	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4165	<	}
4166	<	{
4167	<	_v = (PyInt_Check(argv[4]) || PyLong_Check(argv[4])) ? 1 : 0;
4168	<	}
4169	<	if (_v) {
4170	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4171	<	}
4172	<	}
4173	<	}
4174	<	}
4968	>	}
4969	>	if (obj6) {
4970	>	{
4971	>	if (PyString_Check(obj6))
4972	>	arg7 = std::string(PyString_AsString(obj6));
4973	>	else
4974	>	SWIG_exception(SWIG_TypeError, "string expected");
4975		}
4976		}
4977	<	if ((argc >= 1) && (argc <= 4)) {
4178	<	int _v;
4977	>	if (obj7) {
4978		{
4979	<	void *ptr;
4980	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4981	<	_v = 0;
4982	<	PyErr_Clear();
4184	<	}else {
4185	<	_v = 1;
4186	<	}
4979	>	if (PyString_Check(obj7))
4980	>	arg8 = std::string(PyString_AsString(obj7));
4981	>	else
4982	>	SWIG_exception(SWIG_TypeError, "string expected");
4983		}
4984	<	if (_v) {
4985	<	if (argc <= 1) {
4986	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4987	<	}
4988	<	{
4989	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4990	<	}
4991	<	if (_v) {
4992	<	if (argc <= 2) {
4993	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4994	<	}
4199	<	{
4200	<	_v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
4201	<	}
4202	<	if (_v) {
4203	<	if (argc <= 3) {
4204	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4205	<	}
4206	<	{
4207	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4208	<	}
4209	<	if (_v) {
4210	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4211	<	}
4212	<	}
4213	<	}
4984	>	}
4985	>	{
4986	>	try {
4987	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4988	>
4989	>	}catch (const BossSchedFailure & e) {
4990	>	PyErr_SetString ( SchedulerError, e.what() );
4991	>	return NULL;
4992	>	}catch (const std::exception& e) {
4993	>	PyErr_SetString ( BossError, e.what() );
4994	>	return NULL;
4995		}
4996		}
4997	<
4998	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
4997	>	resultobj = PyInt_FromLong((long)result);
4998	>	return resultobj;
4999	>	fail:
5000		return NULL;
5001		}
5002
#	Line 4231 | Line 5013 | static PyObject *_wrap_BossTask_query(Py
5013		std::string arg6 = (std::string) "" ;
5014		std::string arg7 = (std::string) "" ;
5015		std::string arg8 = (std::string) "" ;
5016	<	bool arg9 = (bool) false ;
5016	>	unsigned int arg9 = (unsigned int) 0 ;
5017	>	bool arg10 = (bool) false ;
5018		int result;
5019		std::string temp3 ;
5020		std::string temp4 ;
#	Line 4243 | Line 5026 | static PyObject *_wrap_BossTask_query(Py
5026		PyObject * obj6 = 0 ;
5027		PyObject * obj7 = 0 ;
5028		PyObject * obj8 = 0 ;
5029	+	PyObject * obj9 = 0 ;
5030
5031	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5031	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5032		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5033		if (obj2) {
5034		{
#	Line 4299 | Line 5083 | static PyObject *_wrap_BossTask_query(Py
5083		}
5084		}
5085		if (obj8) {
5086	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5086	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5087	>	if (PyErr_Occurred()) SWIG_fail;
5088	>	}
5089	>	if (obj9) {
5090	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5091		if (PyErr_Occurred()) SWIG_fail;
5092		}
5093		{
5094		try {
5095	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5095	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5096
5097	+	}catch (const BossSchedFailure & e) {
5098	+	PyErr_SetString ( SchedulerError, e.what() );
5099	+	return NULL;
5100		}catch (const std::exception& e) {
5101	<	SWIG_exception(SWIG_RuntimeError, e.what());
5101	>	PyErr_SetString ( BossError, e.what() );
5102	>	return NULL;
5103		}
5104		}
5105		resultobj = PyInt_FromLong((long)result);
#	Line 4365 | Line 5157 | static PyObject *_wrap_BossTask_query_ou
5157		try {
5158		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5159
5160	+	}catch (const BossSchedFailure & e) {
5161	+	PyErr_SetString ( SchedulerError, e.what() );
5162	+	return NULL;
5163		}catch (const std::exception& e) {
5164	<	SWIG_exception(SWIG_RuntimeError, e.what());
5164	>	PyErr_SetString ( BossError, e.what() );
5165	>	return NULL;
5166		}
5167		}
5168		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4387 | Line 5183 | static PyObject *_wrap_BossTask_clear(Py
5183		try {
5184		(arg1)->clear();
5185
5186	+	}catch (const BossSchedFailure & e) {
5187	+	PyErr_SetString ( SchedulerError, e.what() );
5188	+	return NULL;
5189		}catch (const std::exception& e) {
5190	<	SWIG_exception(SWIG_RuntimeError, e.what());
5190	>	PyErr_SetString ( BossError, e.what() );
5191	>	return NULL;
5192		}
5193		}
5194		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4398 | Line 5198 | static PyObject *_wrap_BossTask_clear(Py
5198		}
5199
5200
5201	<	static PyObject *_wrap_BossTask_prompt(PyObject *self, PyObject *args) {
5201	>	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5202	>	PyObject *resultobj;
5203	>	BossTask *arg1 = (BossTask *) 0 ;
5204	>	PyObject *arg2 = (PyObject *) 0 ;
5205	>	BossAttributeContainer *arg3 = 0 ;
5206	>	PyObject *result;
5207	>	PyObject * obj0 = 0 ;
5208	>	PyObject * obj1 = 0 ;
5209	>	PyObject * obj2 = 0 ;
5210	>
5211	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5212	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5213	>	arg2 = obj1;
5214	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5215	>	if (arg3 == NULL) {
5216	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5217	>	}
5218	>	{
5219	>	try {
5220	>	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5221	>
5222	>	}catch (const BossSchedFailure & e) {
5223	>	PyErr_SetString ( SchedulerError, e.what() );
5224	>	return NULL;
5225	>	}catch (const std::exception& e) {
5226	>	PyErr_SetString ( BossError, e.what() );
5227	>	return NULL;
5228	>	}
5229	>	}
5230	>	resultobj = result;
5231	>	return resultobj;
5232	>	fail:
5233	>	return NULL;
5234	>	}
5235	>
5236	>
5237	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5238	>	PyObject *resultobj;
5239	>	BossTask *arg1 = (BossTask *) 0 ;
5240	>	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5241	>	PyObject *result;
5242	>	PyObject * obj0 = 0 ;
5243	>	PyObject * obj1 = 0 ;
5244	>
5245	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
5246	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5247	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5248	>	if (arg2 == NULL) {
5249	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5250	>	}
5251	>	{
5252	>	try {
5253	>	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
5254	>
5255	>	}catch (const BossSchedFailure & e) {
5256	>	PyErr_SetString ( SchedulerError, e.what() );
5257	>	return NULL;
5258	>	}catch (const std::exception& e) {
5259	>	PyErr_SetString ( BossError, e.what() );
5260	>	return NULL;
5261	>	}
5262	>	}
5263	>	resultobj = result;
5264	>	return resultobj;
5265	>	fail:
5266	>	return NULL;
5267	>	}
5268	>
5269	>
5270	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5271	>	PyObject *resultobj;
5272	>	BossTask *arg1 = (BossTask *) 0 ;
5273	>	PyObject *result;
5274	>	PyObject * obj0 = 0 ;
5275	>
5276	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5277	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5278	>	{
5279	>	try {
5280	>	result = (PyObject *)BossTask_jobsDict(arg1);
5281	>
5282	>	}catch (const BossSchedFailure & e) {
5283	>	PyErr_SetString ( SchedulerError, e.what() );
5284	>	return NULL;
5285	>	}catch (const std::exception& e) {
5286	>	PyErr_SetString ( BossError, e.what() );
5287	>	return NULL;
5288	>	}
5289	>	}
5290	>	resultobj = result;
5291	>	return resultobj;
5292	>	fail:
5293	>	return NULL;
5294	>	}
5295	>
5296	>
5297	>	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5298	>	PyObject *resultobj;
5299	>	BossTask *arg1 = (BossTask *) 0 ;
5300	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5301	>	PyObject *result;
5302	>	PyObject * obj0 = 0 ;
5303	>	PyObject * obj1 = 0 ;
5304	>
5305	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5306	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5307	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5308	>	if (arg2 == NULL) {
5309	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5310	>	}
5311	>	{
5312	>	try {
5313	>	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5314	>
5315	>	}catch (const BossSchedFailure & e) {
5316	>	PyErr_SetString ( SchedulerError, e.what() );
5317	>	return NULL;
5318	>	}catch (const std::exception& e) {
5319	>	PyErr_SetString ( BossError, e.what() );
5320	>	return NULL;
5321	>	}
5322	>	}
5323	>	resultobj = result;
5324	>	return resultobj;
5325	>	fail:
5326	>	return NULL;
5327	>	}
5328	>
5329	>
5330	>	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5331		PyObject *resultobj;
5332		BossTask *arg1 = (BossTask *) 0 ;
5333		std::string *arg2 = 0 ;
5334	<	bool result;
5334	>	PyObject *result;
5335		std::string temp2 ;
5336		PyObject * obj0 = 0 ;
5337		PyObject * obj1 = 0 ;
5338
5339	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_prompt",&obj0,&obj1)) goto fail;
5339	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5340		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5341		{
5342		if (PyString_Check(obj1)) {
#	Line 4419 | Line 5348 | static PyObject *_wrap_BossTask_prompt(P
5348		}
5349		{
5350		try {
5351	<	result = (bool)(arg1)->prompt((std::string const &)*arg2);
5351	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5352
5353	+	}catch (const BossSchedFailure & e) {
5354	+	PyErr_SetString ( SchedulerError, e.what() );
5355	+	return NULL;
5356		}catch (const std::exception& e) {
5357	<	SWIG_exception(SWIG_RuntimeError, e.what());
5357	>	PyErr_SetString ( BossError, e.what() );
5358	>	return NULL;
5359		}
5360		}
5361	<	resultobj = PyInt_FromLong((long)result);
5361	>	resultobj = result;
5362		return resultobj;
5363		fail:
5364		return NULL;
#	Line 4442 | Line 5375 | static PyObject * BossTask_swigregister(
5375		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
5376		PyObject *resultobj;
5377		std::string arg1 = (std::string) "" ;
5378	<	bool arg2 = (bool) false ;
5378	>	std::string arg2 = (std::string) "2" ;
5379	>	std::string arg3 = (std::string) "" ;
5380	>	std::string arg4 = (std::string) "" ;
5381	>	bool arg5 = (bool) false ;
5382		BossAdministratorSession *result;
5383		PyObject * obj0 = 0 ;
5384		PyObject * obj1 = 0 ;
5385	+	PyObject * obj2 = 0 ;
5386	+	PyObject * obj3 = 0 ;
5387	+	PyObject * obj4 = 0 ;
5388
5389	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
5389	>	if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5390		if (obj0) {
5391		{
5392		if (PyString_Check(obj0))
#	Line 4457 | Line 5396 | static PyObject *_wrap_new_BossAdministr
5396		}
5397		}
5398		if (obj1) {
5399	<	arg2 = PyInt_AsLong(obj1) ? true : false;
5399	>	{
5400	>	if (PyString_Check(obj1))
5401	>	arg2 = std::string(PyString_AsString(obj1));
5402	>	else
5403	>	SWIG_exception(SWIG_TypeError, "string expected");
5404	>	}
5405	>	}
5406	>	if (obj2) {
5407	>	{
5408	>	if (PyString_Check(obj2))
5409	>	arg3 = std::string(PyString_AsString(obj2));
5410	>	else
5411	>	SWIG_exception(SWIG_TypeError, "string expected");
5412	>	}
5413	>	}
5414	>	if (obj3) {
5415	>	{
5416	>	if (PyString_Check(obj3))
5417	>	arg4 = std::string(PyString_AsString(obj3));
5418	>	else
5419	>	SWIG_exception(SWIG_TypeError, "string expected");
5420	>	}
5421	>	}
5422	>	if (obj4) {
5423	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5424		if (PyErr_Occurred()) SWIG_fail;
5425		}
5426		{
5427		try {
5428	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
5428	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5429
5430	+	}catch (const BossSchedFailure & e) {
5431	+	PyErr_SetString ( SchedulerError, e.what() );
5432	+	return NULL;
5433		}catch (const std::exception& e) {
5434	<	SWIG_exception(SWIG_RuntimeError, e.what());
5434	>	PyErr_SetString ( BossError, e.what() );
5435	>	return NULL;
5436		}
5437		}
5438		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 4486 | Line 5453 | static PyObject *_wrap_delete_BossAdmini
5453		try {
5454		delete arg1;
5455
5456	+	}catch (const BossSchedFailure & e) {
5457	+	PyErr_SetString ( SchedulerError, e.what() );
5458	+	return NULL;
5459		}catch (const std::exception& e) {
5460	<	SWIG_exception(SWIG_RuntimeError, e.what());
5460	>	PyErr_SetString ( BossError, e.what() );
5461	>	return NULL;
5462		}
5463		}
5464		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4509 | Line 5480 | static PyObject *_wrap_BossAdministrator
5480		try {
5481		result = (int)(arg1)->configureDB();
5482
5483	+	}catch (const BossSchedFailure & e) {
5484	+	PyErr_SetString ( SchedulerError, e.what() );
5485	+	return NULL;
5486		}catch (const std::exception& e) {
5487	<	SWIG_exception(SWIG_RuntimeError, e.what());
5487	>	PyErr_SetString ( BossError, e.what() );
5488	>	return NULL;
5489		}
5490		}
5491		resultobj = PyInt_FromLong((long)result);
#	Line 4543 | Line 5518 | static PyObject *_wrap_BossAdministrator
5518		try {
5519		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5520
5521	+	}catch (const BossSchedFailure & e) {
5522	+	PyErr_SetString ( SchedulerError, e.what() );
5523	+	return NULL;
5524		}catch (const std::exception& e) {
5525	<	SWIG_exception(SWIG_RuntimeError, e.what());
5525	>	PyErr_SetString ( BossError, e.what() );
5526	>	return NULL;
5527		}
5528		}
5529		resultobj = PyInt_FromLong((long)result);
#	Line 4577 | Line 5556 | static PyObject *_wrap_BossAdministrator
5556		try {
5557		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5558
5559	+	}catch (const BossSchedFailure & e) {
5560	+	PyErr_SetString ( SchedulerError, e.what() );
5561	+	return NULL;
5562		}catch (const std::exception& e) {
5563	<	SWIG_exception(SWIG_RuntimeError, e.what());
5563	>	PyErr_SetString ( BossError, e.what() );
5564	>	return NULL;
5565		}
5566		}
5567		resultobj = PyInt_FromLong((long)result);
#	Line 4611 | Line 5594 | static PyObject *_wrap_BossAdministrator
5594		try {
5595		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5596
5597	+	}catch (const BossSchedFailure & e) {
5598	+	PyErr_SetString ( SchedulerError, e.what() );
5599	+	return NULL;
5600		}catch (const std::exception& e) {
5601	<	SWIG_exception(SWIG_RuntimeError, e.what());
5601	>	PyErr_SetString ( BossError, e.what() );
5602	>	return NULL;
5603		}
5604		}
5605		resultobj = PyInt_FromLong((long)result);
#	Line 4645 | Line 5632 | static PyObject *_wrap_BossAdministrator
5632		try {
5633		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5634
5635	+	}catch (const BossSchedFailure & e) {
5636	+	PyErr_SetString ( SchedulerError, e.what() );
5637	+	return NULL;
5638		}catch (const std::exception& e) {
5639	<	SWIG_exception(SWIG_RuntimeError, e.what());
5639	>	PyErr_SetString ( BossError, e.what() );
5640	>	return NULL;
5641		}
5642		}
5643		resultobj = PyInt_FromLong((long)result);
#	Line 4679 | Line 5670 | static PyObject *_wrap_BossAdministrator
5670		try {
5671		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5672
5673	+	}catch (const BossSchedFailure & e) {
5674	+	PyErr_SetString ( SchedulerError, e.what() );
5675	+	return NULL;
5676		}catch (const std::exception& e) {
5677	<	SWIG_exception(SWIG_RuntimeError, e.what());
5677	>	PyErr_SetString ( BossError, e.what() );
5678	>	return NULL;
5679		}
5680		}
5681		resultobj = PyInt_FromLong((long)result);
#	Line 4745 | Line 5740 | static PyObject *_wrap_BossAdministrator
5740		try {
5741		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5742
5743	+	}catch (const BossSchedFailure & e) {
5744	+	PyErr_SetString ( SchedulerError, e.what() );
5745	+	return NULL;
5746		}catch (const std::exception& e) {
5747	<	SWIG_exception(SWIG_RuntimeError, e.what());
5747	>	PyErr_SetString ( BossError, e.what() );
5748	>	return NULL;
5749		}
5750		}
5751		resultobj = PyInt_FromLong((long)result);
#	Line 4835 | Line 5834 | static PyObject *_wrap_BossAdministrator
5834		try {
5835		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5836
5837	+	}catch (const BossSchedFailure & e) {
5838	+	PyErr_SetString ( SchedulerError, e.what() );
5839	+	return NULL;
5840		}catch (const std::exception& e) {
5841	<	SWIG_exception(SWIG_RuntimeError, e.what());
5841	>	PyErr_SetString ( BossError, e.what() );
5842	>	return NULL;
5843		}
5844		}
5845		resultobj = PyInt_FromLong((long)result);
#	Line 4911 | Line 5914 | static PyObject *_wrap_BossAdministrator
5914		try {
5915		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5916
5917	+	}catch (const BossSchedFailure & e) {
5918	+	PyErr_SetString ( SchedulerError, e.what() );
5919	+	return NULL;
5920		}catch (const std::exception& e) {
5921	<	SWIG_exception(SWIG_RuntimeError, e.what());
5921	>	PyErr_SetString ( BossError, e.what() );
5922	>	return NULL;
5923		}
5924		}
5925		resultobj = PyInt_FromLong((long)result);
#	Line 4940 | Line 5947 | static PyObject *_wrap_BossAdministrator
5947		std::string arg13 = (std::string) "" ;
5948		bool arg14 = (bool) false ;
5949		bool arg15 = (bool) false ;
5950	+	bool arg16 = (bool) false ;
5951	+	bool arg17 = (bool) false ;
5952		int result;
5953		std::string temp2 ;
5954		std::string temp11 ;
#	Line 4958 | Line 5967 | static PyObject *_wrap_BossAdministrator
5967		PyObject * obj12 = 0 ;
5968		PyObject * obj13 = 0 ;
5969		PyObject * obj14 = 0 ;
5970	+	PyObject * obj15 = 0 ;
5971	+	PyObject * obj16 = 0 ;
5972
5973	<	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;
5973	>	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;
5974		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5975		{
5976		if (PyString_Check(obj1)) {
#	Line 5067 | Line 6078 | static PyObject *_wrap_BossAdministrator
6078		arg15 = PyInt_AsLong(obj14) ? true : false;
6079		if (PyErr_Occurred()) SWIG_fail;
6080		}
6081	+	if (obj15) {
6082	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6083	+	if (PyErr_Occurred()) SWIG_fail;
6084	+	}
6085	+	if (obj16) {
6086	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6087	+	if (PyErr_Occurred()) SWIG_fail;
6088	+	}
6089		{
6090		try {
6091	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
6091	>	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);
6092
6093	+	}catch (const BossSchedFailure & e) {
6094	+	PyErr_SetString ( SchedulerError, e.what() );
6095	+	return NULL;
6096		}catch (const std::exception& e) {
6097	<	SWIG_exception(SWIG_RuntimeError, e.what());
6097	>	PyErr_SetString ( BossError, e.what() );
6098	>	return NULL;
6099		}
6100		}
6101		resultobj = PyInt_FromLong((long)result);
#	Line 5094 | Line 6117 | static PyObject *_wrap_BossAdministrator
6117		try {
6118		result = (arg1)->help();
6119
6120	+	}catch (const BossSchedFailure & e) {
6121	+	PyErr_SetString ( SchedulerError, e.what() );
6122	+	return NULL;
6123		}catch (const std::exception& e) {
6124	<	SWIG_exception(SWIG_RuntimeError, e.what());
6124	>	PyErr_SetString ( BossError, e.what() );
6125	>	return NULL;
6126		}
6127		}
6128		{
#	Line 5133 | Line 6160 | static PyObject *_wrap_BossAdministrator
6160		try {
6161		result = (arg1)->SQL(arg2,arg3);
6162
6163	+	}catch (const BossSchedFailure & e) {
6164	+	PyErr_SetString ( SchedulerError, e.what() );
6165	+	return NULL;
6166		}catch (const std::exception& e) {
6167	<	SWIG_exception(SWIG_RuntimeError, e.what());
6167	>	PyErr_SetString ( BossError, e.what() );
6168	>	return NULL;
6169		}
6170		}
6171		{
#	Line 5205 | Line 6236 | static PyObject *_wrap_BossAdministrator
6236		try {
6237		result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6238
6239	+	}catch (const BossSchedFailure & e) {
6240	+	PyErr_SetString ( SchedulerError, e.what() );
6241	+	return NULL;
6242		}catch (const std::exception& e) {
6243	<	SWIG_exception(SWIG_RuntimeError, e.what());
6243	>	PyErr_SetString ( BossError, e.what() );
6244	>	return NULL;
6245	>	}
6246	>	}
6247	>	resultobj = PyInt_FromLong((long)result);
6248	>	return resultobj;
6249	>	fail:
6250	>	return NULL;
6251	>	}
6252	>
6253	>
6254	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
6255	>	PyObject *resultobj;
6256	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6257	>	std::string arg2 ;
6258	>	int result;
6259	>	PyObject * obj0 = 0 ;
6260	>	PyObject * obj1 = 0 ;
6261	>
6262	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
6263	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6264	>	{
6265	>	if (PyString_Check(obj1))
6266	>	arg2 = std::string(PyString_AsString(obj1));
6267	>	else
6268	>	SWIG_exception(SWIG_TypeError, "string expected");
6269	>	}
6270	>	{
6271	>	try {
6272	>	result = (int)(arg1)->registerPlugins(arg2);
6273	>
6274	>	}catch (const BossSchedFailure & e) {
6275	>	PyErr_SetString ( SchedulerError, e.what() );
6276	>	return NULL;
6277	>	}catch (const std::exception& e) {
6278	>	PyErr_SetString ( BossError, e.what() );
6279	>	return NULL;
6280		}
6281		}
6282		resultobj = PyInt_FromLong((long)result);
#	Line 5239 | Line 6309 | static PyMethodDef SwigMethods[] = {
6309		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
6310		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
6311		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
6312	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6313	<	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6314	<	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6315	<	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6316	<	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6317	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6312	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
6313	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
6314	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
6315	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
6316	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
6317	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
6318	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
6319	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
6320	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
6321	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
6322	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
6323	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6324	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6325	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
6326		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6327		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6328	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6329		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6330		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6331		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6332	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6333	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6334	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6335	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6336		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6337		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6338		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5257 | Line 6340 | static PyMethodDef SwigMethods[] = {
6340		{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
6341		{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
6342		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
5260	–	{ (char *)"BossSession_purgeTasks", _wrap_BossSession_purgeTasks, METH_VARARGS },
6343		{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6344		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6345		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
5264	–	{ (char *)"BossSession_queryPrint", _wrap_BossSession_queryPrint, METH_VARARGS },
6346		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6347	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6348	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6349	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6350	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6351	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6352	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6353	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6354	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6355		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6356		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6357		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 5270 | Line 6359 | static PyMethodDef SwigMethods[] = {
6359		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6360		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6361		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5273	–	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5274	–	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5275	–	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5276	–	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5277	–	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6362		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6363		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6364		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
6365		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
6366	<	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6366	>	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6367		{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6368		{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
6369	<	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6369	>	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
6370	>	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6371		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6372	+	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6373		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
6374		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
6375		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
5290	–	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6376		{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
6377		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6378		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6379		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
6380	+	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6381		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6382		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6383		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6384	<	{ (char *)"BossTask_prompt", _wrap_BossTask_prompt, METH_VARARGS },
6384	>	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6385	>	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6386	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6387	>	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6388	>	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6389		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
6390		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6391		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 5312 | Line 6402 | static PyMethodDef SwigMethods[] = {
6402		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
6403		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
6404		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
6405	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
6406		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
6407		{ NULL, NULL }
6408		};
#	Line 5319 | Line 6410 | static PyMethodDef SwigMethods[] = {
6410
6411		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6412
5322	–	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}};
5323	–	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}};
5324	–	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}};
6413		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6414	+	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}};
6415	+	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}};
6416	+	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}};
6417		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}};
6418		static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6419		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6420		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
5330	–	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6421		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6422	<	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6422	>	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6423		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6424	+	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6425		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6426		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}};
6427		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}};
6428		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
5338	–	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6429		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}};
6430		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}};
6431	+	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6432
6433		static swig_type_info *swig_types_initial[] = {
5343	–	_swigt__p_std__vectorTBossJob_p_t,
5344	–	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
5345	–	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6434		_swigt__p_XMLDoc,
6435	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6436	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6437	+	_swigt__p_std__vectorTBossTask_p_t,
6438		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6439		_swigt__p_std__ostream,
6440		_swigt__p_BossTask,
6441		_swigt__p_BossTaskException,
5351	–	_swigt__p_BossAttributeContainer,
6442		_swigt__p_printOption,
6443	<	_swigt__p_BossDatabase,
6443	>	_swigt__p_BossAttributeContainer,
6444		_swigt__p_BossJob,
6445	+	_swigt__p_BossDatabase,
6446		_swigt__p_BossSession,
6447		_swigt__p_std__vectorTstd__string_t,
6448		_swigt__p_std__mapTstd__string_std__string_t,
6449		_swigt__p_BossAdministratorSession,
5359	–	_swigt__p_jobStates,
6450		_swigt__p_std__vectorTBossJob_p_t__const_iterator,
6451		_swigt__p_BossTask__job_iterator,
6452	+	_swigt__p_jobStates,
6453		0
6454		};
6455
#	Line 5401 | Line 6492 | SWIGEXPORT(void) SWIG_init(void) {
6492		}
6493		SWIG_InstallConstants(d,swig_const_table);
6494
6495	+
6496	+	// define custom exceptions
6497	+	PyObject *e;
6498	+	PyMethodDef tp_methods = {
6499	+	NULL, NULL, 0, NULL
6500	+	};
6501	+	e = Py_InitModule("BossSession", &tp_methods);
6502	+	// generic BOSS exception
6503	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
6504	+	Py_INCREF(BossError);
6505	+	PyModule_AddObject(e, "BossError", BossError);
6506	+	// scheduler interaction BOSS exception
6507	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
6508	+	Py_INCREF(SchedulerError);
6509	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
6510	+
6511		}
6512

Diff Legend

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