[ViewVC] Diff of: cvsroot/COMP/BOSS/BossPython/BossSession

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.6 by gcodispo, Fri Oct 27 12:45:31 2006 UTC vs.
Revision 1.24 by gcodispo, Fri Mar 2 14:13:39 2007 UTC

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

Diff Legend

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents): Revision 1.6 by gcodispo, Fri Oct 27 12:45:31 2006 UTC vs. Revision 1.24 by gcodispo, Fri Mar 2 14:13:39 2007 UTC

Diff Legend

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.6 by gcodispo, Fri Oct 27 12:45:31 2006 UTC vs.
Revision 1.24 by gcodispo, Fri Mar 2 14:13:39 2007 UTC