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

Diff Legend

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