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

Diff Legend

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