ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.7 by gcodispo, Fri Oct 27 13:36:09 2006 UTC vs.
Revision 1.20 by gcodispo, Thu Dec 14 11:40:04 2006 UTC

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

Diff Legend

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